package core;

//Неправильный переход при ошибке соединения
//Номера телефонов

 //Порыка Васыля

//кнопки для нокии
//Command.STOP - всегда справа, но если есть поле ввода текста - перескакивает налево
//Command.OK - по центру, но если есть ChoiceGroup любого типа - перескакивает налево

import com.sun.lwuit.Command;
import view.RegionsFilterForm;
import utils.Utils;
import view.additional.CellItem;
import com.sun.lwuit.Dialog;
import com.sun.lwuit.Display;
import com.sun.lwuit.Font;
import com.sun.lwuit.Form;
import com.sun.lwuit.TextArea;
import com.sun.lwuit.events.ActionEvent;
import com.sun.lwuit.layouts.BorderLayout;
import com.sun.lwuit.plaf.UIManager;
import com.sun.lwuit.util.Resources;
import javax.microedition.midlet.MIDlet;
import javax.microedition.media.control.VolumeControl;
import javax.microedition.media.Player;
import javax.microedition.media.Manager;
import java.io.InputStream;
import java.util.Hashtable;
import java.util.Timer;
import java.util.TimerTask;
import javax.microedition.lcdui.AlertType;
import javax.microedition.rms.RecordStore;
import networkrespnse.CallSignChangedResponse;
import networkrespnse.CancelEfirOrder;
import networkrespnse.ChangeState;
import networkrespnse.ClearEfir;
import networkrespnse.DriverMessageResponse;
import networkrespnse.DriverParkingPositionResponse;
import networkrespnse.GetCSBalanceAnswer;
import networkrespnse.GetOrdersResponse;
import networkrespnse.LoginResponse;
import networkrespnse.OrderResponse;
import networkrespnse.PPCSettingsResponse;
import networkrespnse.PreOrdersResponse;
import networkrespnse.RefusePreliminaryOrderAnswer;
import networkrespnse.RegisterOnTaxiParkingResponse;
import networkrespnse.RelayCommunicationResponse;
import networkrespnse.Response;
import networkrespnse.SQLResponse;
import networkrespnse.SettingsXML;
import networkrespnse.TCPMessageResponse;
import networkrespnse.TaxiParkingStatisticResponse;
import networkrespnse.TaxiParkingsLastChangeDateResponse;
import networkrespnse.TaxiParkingsResponse;
import networkrespnse.UnRegisterOnTaxiParkingResponse;
import networkrespnse.WorkReportResponse;
import utils.SettingsLoader;
import view.ActionManager;
import view.ArchiveDetails;
import view.ArchiveOrdersList;
import view.ArchivesMenuList;
import view.DynamicForm;
import view.EfirOrdersList;
import view.FormAction;
import view.FunctionMenu;
import view.OptionsForm;
import view.EfirOrderDetails;
import view.ExitMenu;
import view.FeedForm;
import view.LoadForm;
import view.LogForm;
import view.MessageForm;
import view.MessageList;
import view.OrderDetails;
import view.OrdersList;
import view.ParkingList;
import view.PasswordEnteringForm;
import view.PhoneForm;
import view.PreOrderDetails;
import view.RegionList;
import view.SettingsForm;
import view.StatisticList;
import view.SumFilterForm;
import view.ViewManager;
import view.ProgressForm;
import view.ReportForm;
import view.DefaultTimeSelectForm;
import view.TimeSelectForm;
import view.UnregisterConfirmation;

public class MainOne extends MIDlet implements Action,OrderListener,InterfaceAction,ReconnectAction
{
    private static final int PN_UPDATE_PREORDERS_COUNT = 7;
    private static final long MIN_REPAINT_PERIOD = 2000;
    private static final long GET_TEN_MINUTES_ORDER_PERIOD = 3000;
    
    //For settings 
    private static final String SERVER_IP_SETTING = "serverip";
    public static final String LOGIN_SETTING = "login";  
    public static final String PASSWORD_SETTING = "password";
    public static final String CALLSIGN_SETTING = "callsign";
    public static final String DISPATCHER_NUMBER_SETTING = "dispatcher_number";
    public static final String PREORDERS_UPDATE_PERIOD_SETTING = "preorders_update";
    
    private static final String[] MESSAGE_PATTERNS = new String[]{"Поиск водителей окончен или не ведется", "Заявка на заказ отправлена",
                                                                    "Поиск не ведется", "Удачи погороду", "Заказ ваш, ждите оформления",
                                                                    "Заказ помечен как исполняемый"};
    private static MainOne self;
    private boolean pause;
    public static String LOG_STR;
    private final int TIMEOUT = 60000;
    //private final Object lock = new Object();
    private Timer preordersUpdateTimer;
    
    private LogForm logForm = null;

    //Форма подтверждения снятия с сектора
    private UnregisterConfirmation unregisterConfirmation;
    //----------------------------
    //Форма отображения времени ожидания
    private TimeSelectForm waitForm;
    //----------------------------
    //Форма отображения деталей заказа
    private EfirOrderDetails orderDetails;
    //-----------------------
    //Форма отображения функций меню
    private FunctionMenu functionMenu;
    //-----------------------
    //Форма отображения новых заказов
    private EfirOrdersList efirOrdersList;
    //-----------------------
    //Форма отображения заказов из архива
    private ArchiveOrdersList archiveOrdersList;
    //-----------------------
    //Форма отображения списка сообщений
    private MessageList messageList;
    //-----------------------
    //Форма отображения списка сообщений, относящегося к конкретному заказу
    private MessageList archiveOrdersMessageList;
    //-----------------------
    //Форма отображения списка сообщений, относящегося к конкретному заказу
    private MessageList ordersMessageList;
    //-----------------------
    //Форма отображения деталей старого заказа
    private OrderDetails orderOldDetails; 
    //-----------------------
    //Форма выхода из приложения
    private ExitMenu exitMenu;
    //-----------------------
    //Форма отображения старых заказов
    private OrdersList oldOrdersList;
    //-----------------------
    //Меню с архивом заказов
    private ArchivesMenuList archivesMenuList; 
    //-----------------------
    //детали по сообщению из архива
    private ArchiveDetails orderArchiveDetails;
    //-----------------------
    //Форма загрузки
    private ProgressForm progressForm;
    private Timer timer;
    private TimerTask cancelTask;
    //-----------------------
    //Форма настроек
    private SettingsForm settingsForm;
    //-----------------------
    //Форма дополнительных настроек
    private OptionsForm optionsForm; 
    //-----------------------
    //Общие данные
    private Form prevForm;   
    private OrderManager orderManager;
    private Connection connection;
    private ParameterBuilder parameterBuilder;
    private ParameterDecoder parameterDecoder;
    private PositionManager positionManager;
    private MessageManager messageManager;
    private ConnectionChecker connectionChecker;
    private Parameters parameters;
    private Timer reconnectTimer;
    private int menuType;

    //Класс временных данных
    private RuntimeData rd;
    //----------------------------
    //Данные для проигрования звука
    private InputStream is;
    private Player player;
    //----------------------------
    //Форма ввода пароля для настроек
    private PasswordEnteringForm passwordFormSettings;
    //-----------------------
    //Форма ввода пароля для позывного
    private PasswordEnteringForm passwordEnteringForm;
    //-----------------------
    //Формы регистрации в секторе
    private RegionList regionList;
    private ParkingList parkingList;
    //-----------------------
    //Форма отображения статистики
    private RegionList statisticRegionList; 
    private StatisticList statisticList;   
    //-----------------------
    //Форма ожидания
    private TimeSelectForm driverWaiting;
    //-----------------------
    //Форма "не выходят"
    private TimeSelectForm passengerOut;
    //-----------------------
    //Форма отображения деталей выполненного заказа
    private ArchiveDetails orderСompletedDetails;
    //-----------------------
    //Форма задержки водителя
    private TimeSelectForm driverDelayForm;
    //-----------------------
    //Форма изменения времени подачи
    private FeedForm feedForm;
    //-----------------------
    //Форма отображения сообщений
    private MessageForm messageForm;
    //-----------------------
    //Форма отображения сообщений по заказу
    private MessageForm orderMessageForm;
    //-----------------------
    //Форма отображения сообщений по заказу
    private MessageForm archiveOrderMessageForm;
    //-----------------------
    //Форма отчетов
    private ReportForm reportForm;
    //-----------------------
    //Форма сообщения о загрузке новой версии
    private LoadForm loadForm;
    //--------------------
    //Форма фильтра
    private RegionsFilterForm regionsFilterForm;
    private RegionsFilter regionsFilter;
    //--------------------
    //Форма фильтра по сумме
    private SumFilterForm sumFilterForm;
    //--------------------
    //Форма звонков
    private PhoneForm phoneForm;
    //--------------------
    //Форма предварительных заказов
    private OrdersList preOrdersList;
    //--------------------
    //Форма отображения деталей предварительного заказа
    private PreOrderDetails preOrderDetails;
    //--------------------
    //Форма отображения входящих заказов
    private OrdersList incomingOrdersList;
    //-----------------------
    //Форма отображения моих заказов
    private OrdersList myOrdersList;
    //-----------------------
    private long lastRepaint;
    private long lastGetTenTime;

    private Timer efirMusicReplayer;
    private long lastEfirMusicReplay;
    
    public MainOne()
    {
        super(); 

        init(); 
        lastRepaint = 0;
        lastGetTenTime = 0;
    }

    private void init()
    {
        //Инициализируем переменные
        pause = false;

        timer = null;
        cancelTask = null;

        //Создаем объекты классов
        prevForm = null;
        rd = new RuntimeData();
        parameterBuilder = new ParameterBuilder();
        parameterDecoder = new ParameterDecoder();

        //Долгие операции делаем в отделных потоках
//        Thread t1 = new Thread(new Runnable() {
//
//            public void run()
//            {
//                positionManager = new PositionManager();
//            }
//        });
//        t1.start();
//
//        Thread t2 = new Thread(new Runnable() {
//
//            public void run()
//            {
//                regionsFilter = new RegionsFilter(Settings.getSettings().getFilter());
//            }
//        });
//        t2.start();
//
//        Thread t3 = new Thread(new Runnable() {
//
//            public void run()
//            {
//                Settings.getSettings();
//            }
//        });
//        t3.start();
//
//        Thread t4 = new Thread(new Runnable() {
//
//            public void run()
//            {
//                messageManager = new MessageManager();
//            }
//        });
//        t4.start();
//
//        Thread t5 = new Thread(new Runnable() {
//
//            public void run()
//            {
//                orderManager = new OrderManager(MainOne.this);
//            }
//        });
//        t5.start();
//
//        //Ждем потоки
//        try
//        {
//            t1.join();
//        }catch(Exception ex){}
//         try
//        {
//            t2.join();
//        }catch(Exception ex){}
//         try
//        {
//            t3.join();
//        }catch(Exception ex){}
//         try
//        {
//            t4.join();
//        }catch(Exception ex){}
//         try
//        {
//            t5.join();
//        }catch(Exception ex){}

        positionManager = new PositionManager();
        regionsFilter = new RegionsFilter(Settings.getSettings().getFilter());
        Settings.getSettings();
        messageManager = new MessageManager();
        orderManager = new OrderManager(MainOne.this);
    
        //070996
        if ("wtk-emulator".equals(System.getProperty("device.model")))
        {
            Settings.getSettings().setNick("2" /*"6767"*/);
            Settings.getSettings().setLogin("2"/* "ss"*/);
            Settings.getSettings().setPassword("2");
            Settings.getSettings().setServerIP("194.0.150.90:6000");
      //      Settings.getSettings().setServerIP("194.0.150.90:1111");
            Settings.getSettings().setServerIP("194.48.212.11:6000");
            Settings.getSettings().setTakeOrder(true);
            Settings.getSettings().setFullOrder(true);
            Settings.getSettings().setEfirMusicReplayPeriod(8);
        }

        self = this;      
    }
        
    private void readSettings() {
       Settings settings = Settings.getSettings();
       
       String value = getAppProperty(SERVER_IP_SETTING);
       if (value != null && !value.trim().equals("")) {
           Settings.getSettings().setServerIP(value.trim());
       }
       
       value = getAppProperty(LOGIN_SETTING);
       if (value != null && !value.trim().equals("")) {
           Settings.getSettings().setLogin(value.trim());
       }
       
       value = getAppProperty(CALLSIGN_SETTING);
       if (value != null && !value.trim().equals("")) {
           Settings.getSettings().setNick(value.trim());
       }
       
       value = getAppProperty(PASSWORD_SETTING);
       if (value != null && !value.trim().equals("")) {
           Settings.getSettings().setPassword(value.trim());
       }
       
       value = getAppProperty(DISPATCHER_NUMBER_SETTING);
       if (value != null && !value.trim().equals("")) {
           Settings.getSettings().setDispetcherCall(value.trim());
       }
       
       value = getAppProperty(PREORDERS_UPDATE_PERIOD_SETTING);
       if (value != null && !value.trim().equals("")) { 
           try {
               Settings.getSettings().setPreordersUpdatePeriod(Integer.parseInt(value.trim()));
           } catch (NumberFormatException nfe) {} 
       }
       
       settings.save();
    }
    
    private void readSettingsFormFile() {
        //При использовании этого класса учесть:
        //Раскоментить и проверить чтоб не перезатирало если уже что то есть + руками поправить + русский текст
        //1) utf-8
        //2)первая строка должна быть пустой
        //3) Символ двоеточия используется как разделитель(их не должно быть в значении)
        SettingsLoader loader = new SettingsLoader();
        loader.load(SettingsLoader.SETTINGS_FILE_NAME);
        
        Settings settings = Settings.getSettings(); 
        String item = loader.getItem(SettingsLoader.LOGIN_KEY);
        if (item.equals("")) {
            settings.setLogin(item);
        }
        item = loader.getItem(SettingsLoader.CALLSIGN_KEY); 
        if (item.equals("")) {
            settings.setNick(item);
        }
        item = loader.getItem(SettingsLoader.PASSWORD_KEY); 
        if (item.equals("")) {
            settings.setPassword(item);
        }
        item = loader.getItem(SettingsLoader.IP_KEY) + ":" + loader.getItem(SettingsLoader.PORT_KEY); 
        if (item.equals(":")) {
            settings.setServerIP(item);
        }
        
        settings.save();     
    }
    
    public boolean isConnected()
    {
        return (connection != null && connection.isOpen());
    }

    public static MainOne getMainOne()
    {
        return self;
    }

    public void pauseApp()
    {
        pause = true;
    }

    public void destroyApp(boolean unconditional)
    {
        Settings.getSettings().saveLog();

        messageManager.save();
        orderManager.saveOrders();
        
        if (connection!=null)
	{
            connection.disconnect();
	}
	if (connectionChecker!=null)
	{
            connectionChecker.stop();
	}

        notifyDestroyed();
    }

    public void startApp()
    {
        //Если это возвращение из паузы
        if (pause)
        {
            pause = false;

            showMainMenu();
            return;
        }

        parameters = Parameters.getParameters();

        //Инициализируем визуальную библиотеку
        Display.init(this);
        Display.getInstance().setThirdSoftButton(true);

        //Устанавливаем тему отображения компонентов
        try
        {
            Resources r = Resources.open("/theme/LWUITtheme.res");
            UIManager.getInstance().setThemeProps(r.getTheme(r.getThemeResourceNames()[0]));

            TimerService.getTimerService().setConnectionOn(r.getImage("con_on"));
            TimerService.getTimerService().setConnectionOff(r.getImage("con_off"));
        } catch (Exception e) {}

        //Локализируем некоторые слова
        Hashtable localize = new Hashtable(1);
        localize.put("menu", "Меню");
        localize.put("select", "Выбрать");
        localize.put("cancel", "Отмена");
        localize.put("Clear", "Удалить");
        UIManager.getInstance().setResourceBundle(localize);

        //Регестрируем обработчики
        registerActions(); 

        menuType = ViewManager.getViewManager().getFunctionMenuType();
       
        if (menuType == FunctionMenu.CHERNOVTSI_TYPE || menuType == FunctionMenu.KIROVOGRAD_TYPE) {
            orderManager.setPreorderSignedFont(Font.createSystemFont(Font.FACE_SYSTEM, Font.STYLE_BOLD, Font.SIZE_MEDIUM));
        }
        
        //Загружаем настройки
        if (Settings.getSettings().getServerIP().equals("")) {
            readSettings();
        }
        if (Settings.getSettings().getServerIP().equals(""))
        {
            if (menuType == FunctionMenu.CHERNOVTSI_TYPE)
            {
                Settings.getSettings().setServerIP("195.182.193.71:1111");
            }
            else if (menuType == FunctionMenu.DONETSK_TYPE) {                
                Settings.getSettings().setServerIP("109.254.44.163:2222");
            }
            else
            {
                Settings.getSettings().setServerIP(getAppProperty("serverip"));
            }
        }

        //Задаем слушателя изменения ip
        Settings.getSettings().setIpChangedListener(new SrverIPChanged()
        {
            public void ipChanged(String oldIP, String newIP)
            {
                //Очищаем список позиций
                Settings.getSettings().setLastUpdate(-1l);
                positionManager.clear();
                //Сохраняем список позиций в rms
                positionManager.save();
            }
        });

        Settings.getSettings().setTakeOrderFlagListener(new TakeOrderFlagChanged()
        {
            public void takeOrderFlagChanged(boolean takeOrder)
            {
                if (efirOrdersList != null)
                {
                    efirOrdersList.setTakingOrderCommand(takeOrder);
                }
            }
        });

        createOldOrdersList();
        createRegionsFilterForm();
        //Показываем главное меню
        showMainMenu();
        //Если стоит флаг автовхода - то входим
        if (Settings.getSettings().isAutoEnter())
        {
            doEnter();
        }

        TimerService.getTimerService().start();
        
        startEfirMusicReplayer();
        startSwitchOnDisplayTimer(5000L/*, 10000L*/);
    }

    private void startSwitchOnDisplayTimer(long delay)
    {
        TimerTask task = new TimerTask()
        {
            public void run()
            {
                switchOnDisplay();
            }
        };
                
        Timer t = new Timer();
        t.schedule(task, delay);
    }
    
    private void startEfirMusicReplayer()
    {
        //Если не черновцы - не запускаем
        if (menuType != FunctionMenu.CHERNOVTSI_TYPE)
        {
            return;
        }
        
        lastEfirMusicReplay = 0;
        efirMusicReplayer = new Timer();
        efirMusicReplayer.schedule(new TimerTask()
        {
            public void run()
            {
                long efirMusicReplayPeriod = Settings.getSettings().getEfirMusicReplayPeriod() * 1000L;
                if (lastEfirMusicReplay == 0 || efirMusicReplayPeriod <= 0 || 
                    (System.currentTimeMillis() - lastEfirMusicReplay) < efirMusicReplayPeriod)
                {
                    return;
                }
                if (orderManager.getNewOrderCount() == 0)
                {                     
                    lastEfirMusicReplay = 0;
                    return;
                }
                
                //Запускаем музыку
		if (!Settings.getSettings().isSwitchOffMusic())
		{
                    switch (Settings.getSettings().getVoiceRington())
                    { 
                        case(0): startMusic(0,"/efirord.mid",false); break;
                        case(1): startMusic(0,"/efirord.amr",false); break;
                        case(2): startMusic(0,"/efirord_v.amr",false); break;
                        default: startMusic(0,"/efirord.mid",false); break;
                    }
                    lastEfirMusicReplay = System.currentTimeMillis();
		}
            }
        }, 10000, 2000);
    }
    
    private void switchOnDisplay()
    {
        if (Settings.getSettings().isSwitchLight())
        {
            try
            {
                Class.forName("com.nokia.mid.ui.DeviceControl");
                try
                {
//                    com.nokia.mid.ui.DeviceControl.setLights(0, 100);
                }catch(Exception ex){}
            }
            catch(ClassNotFoundException cnfe){}
        }
    }
    
    private String convertToMD5(String src)
    {
        //convert plaintext into bytes
	byte plain[] = src.getBytes();

	// create MD5 object
	MD5 md5 = new MD5(plain);

	//get the resulting hashed byte
	byte[] result = md5.doFinal();

	//convert the hashed byte into hexadecimal character for display
	String hashResult = md5.toHex(result);
        return hashResult;
    }

    public void setPrev(Form LWUITPrev)
    {
        prevForm = LWUITPrev;
    }

    private void showPrevForm()
    {
        prevForm.show();
    }

    private void showMainMenu()
    {
 //Logger.getInstance().log("showMainMenu");          
        DynamicForm form =  ViewManager.getViewManager().getForm("main_menu");

        if (form != null)
        {
 //Logger.getInstance().log("form != null");           
            setPrev(form);
            form.show();
        }
    }
 
    private void showPasswordFormSettings()
    {
        //Создаем экземпляры классов если надо
        if (passwordFormSettings==null)
        {
            passwordFormSettings = new PasswordEnteringForm(new FormAction() 
            {
                public void commandAction(int commandID)
                {
                    if (commandID == PasswordEnteringForm.OK_ID)
                    {
                        showOptions();
                    }
                    else if (commandID == PasswordEnteringForm.BACK_ID)
                    {
                        //Возвращаемся в главное меню
                        showMainMenu();
                    }
                }
            });
        }

        setPrev( passwordFormSettings);
        //Выводим форму с паролем
        passwordFormSettings.show();
    }

    private void showPasswordForm()
    {        
        //Создаем экземпляры классов если надо
        if (passwordEnteringForm == null)
        {
            passwordEnteringForm = new PasswordEnteringForm(new FormAction()
            {
                public void commandAction(int commandID)
                {
                    if (commandID == PasswordEnteringForm.OK_ID)
                    {
                        showSettings();
                    }
                    else if(commandID == PasswordEnteringForm.BACK_ID)
                    {
                        //Возвращаемся в главное меню
                        showMainMenu();
                    }
                }
            });
        }

        //Выводим форму с паролем
        setPrev(passwordEnteringForm);
        passwordEnteringForm.show();
    }

    private void showSettings()
    {
        //Создаем форму если надо
        if (settingsForm == null)
        {
            settingsForm = new SettingsForm(new FormAction()
            {
                public void commandAction(int commandID)
                {
                    if(commandID == SettingsForm.SAVE_ID)
                    {
                        //Сохраняем настройки
                        Settings.getSettings().saveSettings();

                        //Показываем основное меню
                        showMainMenu();
                    }
                    else if (commandID == SettingsForm.BACK_ID)
                    {
                        //Показываем основное меню
                        showMainMenu();
                    }
                }
            });
        }

        //проверяем правильность пароля
        String enteredPassword = convertToMD5(passwordEnteringForm.getPassword());
        if (enteredPassword.equals(Settings.getSettings().getOptionsPassword()))
        {
            //показываем форму настроек
            setPrev(settingsForm);
            settingsForm.show();
        }
        else
        {
            //Показываем сообщение о неверном пароле
            showAlert("Введен неверный пароль",AlertType.ERROR);
        }
    }

    private void doEnter()
    {      
        //Проверяем чтоб был позывной
        if (Settings.getSettings().getNick().equals(""))
	{
            showAlert("Вы не ввели позывной.Введите его,пожалуйста.",AlertType.ERROR);
            return;
	}
        
        //Проверяем чтоб был логин и пароль
        if (Settings.getSettings().getLogin().equals("")||Settings.getSettings().getPassword().equals(""))
	{
            showAlert("Вы не ввели логин и(или) пароль.Введите их,пожалуйста.",AlertType.ERROR);
            return;
	}

        //Проверяем есть ли соединение.Если есть - показываем меню.Если нет - соединяемся
        if (connection!=null&&connection.isOpen())
	{
            showMainForm();
	}
	else
	{
            StopReconnectTimer();
            //Генерируем данные для залогинивания
            final byte[] data = parameterBuilder.createLogin(255,Settings.getSettings().getLogin(),Settings.getSettings().getPassword(),true);
            showProgressForm(TIMEOUT);
            connection = new Connection(Settings.getSettings().getServerIP(),data,this);
	}
    }
   
    private void showAlert(String text,AlertType type)
    {
        showAlert("",text,type);
    }
    
    private void showAlert(String title, String text, AlertType type)
    {
        Dialog alert = new Dialog(title);
        alert.getContentPane().setLayout(new BorderLayout());

        TextArea message = new TextArea(text, 1, 30);
        message.setAlignment(TextArea.CENTER);
        message.setEditable(false);
        alert.addComponent(BorderLayout.CENTER,message);

        alert.addCommand(new Command("OK",1)
        {
            public void actionPerformed(ActionEvent evt)
            {
                stopMusic();
            }
        });

        alert.showModeless();
        type.playSound(javax.microedition.lcdui.Display.getDisplay(this));
    }

    private void showAlert(String title,String text,AlertType type, Form nextDiaply)
    {
        showAlert(title,text,type,nextDiaply,true);
    }

    private void showAlert(String title,String text,AlertType type, Form nextDiaply,boolean playSound)
    {
        final Form tmp = nextDiaply;

        Dialog alert = new Dialog(title);
        alert.getContentPane().setLayout(new BorderLayout());

        TextArea message = new TextArea(text, 1, 30);
        message.setAlignment(TextArea.CENTER);
        message.setEditable(false);
        alert.addComponent(BorderLayout.CENTER,message);

        alert.addCommand(new Command("OK",1)
        {
            public void actionPerformed(ActionEvent evt)
            {
                stopMusic();
                if (tmp != null)
                {
                    if (tmp != functionMenu)
                    {
                        setPrev(tmp);
                    }
                    tmp.show();
                    evt.consume();
                }
            }
        });

        alert.showModeless();
        
        if (playSound)
        {
            type.playSound(javax.microedition.lcdui.Display.getDisplay(this));
        }
    }

    private void showMainForm()
    {
        DynamicForm form =  ViewManager.getViewManager().getForm("main_form");

        if (form != null)
        {
            actionManagerUpdate();
            setChangeDriverStateText(rd.getDriverState());

            setPrev(form);
            form.show();
        }
    }

    private void showProgressForm(long timeOut)
    {
        progressForm = new ProgressForm(new FormAction()
        {
            public void commandAction(int commandID)
            {
                if (commandID == ProgressForm.CANCEL_ID)
                {
                    //Останавливаем таймер
                    if (timer != null)
                    {
                        timer.cancel();
                        timer = null;
                        cancelTask = null;
                    }

                    //Показываем нужную форму
                    if (prevForm == null)
                    {
                        showMainMenu();
                    }
                    else
                    {
                        showPrevForm();
                    }
                }
            }
        });

        //Запускаем таймер
        cancelTask = new TimerTask()
        {
            public void run()
            {
                actionTimeOut();
            }
        };
        timer = new Timer();
        timer.schedule(cancelTask, timeOut);

        progressForm.show();
    }
 
    public void action(int code,byte[] data)
    {
        if (timer != null)
        {
            timer.cancel();
            timer = null;
            cancelTask = null;
        }

        if (code==1)
        {
            Response response = parameterDecoder.parseResponse(data);

            if (response != null)
            {
                switch(response.getId())
                {
                    case Response.PARSE_ERROR: showAlert("Ошибка парсинга пакета",AlertType.ERROR); break; //Ошибка парсинга пакета
                    case Response.SERVER_ERROR_RESPONSE : showServerError();break;//Ошибка сервера
                    case Response.LOGIN_RESPONSE : loginResponse((LoginResponse)response); break;//Ответ на залогинивание
                    case Response.PING_RESPONSE : pingAnswer();break;//Ответ на пинг
                    case Response.SRV_MESSAGE_RESPONSE : srvMessageAnswer(); break;//Ответ на SrvMessage
                    case Response.REGISTER_ON_TAXI_PARKING_RESPONSE : parkingAnswer((RegisterOnTaxiParkingResponse)response); break;//Ответ на RegisterOnTaxiParking
                    case Response.RELAY_COMMUNICATION_RESPONSE : relayCommunicationAnswer((RelayCommunicationResponse)response);break;//Ответ на RelayCommunication
                    case Response.ORDER_RESPONSE : 
                    case Response.ORDER_RESPONSE2 :    
                    case Response.ORDER_RESPONSE3 :
                    case Response.ORDER_RESPONSE4 : newOrder((OrderResponse)response); break;//Обработка пакета,описывающего заказ
                    case Response.TCPMESSAGE_RESPONSE : incomingTCPMessage((TCPMessageResponse)response); break;//Обработка сообщения по поводу заказа
                    case Response.REQUEST_CONFIRMATION_RESPONSE : showAlert("Выш запрос успешно доставлен диспетчеру", AlertType.INFO); break;//Выводим сообщение на приход RequestConfirmation
                    case Response.TAXI_PARKING_STATISTIC_RESPONSE : showSetParkingForm((TaxiParkingStatisticResponse)response);break;//Пришла статистика по стоянкам - отображаем фору постановки на стоянку
                    case Response.TAXI_PARKING_LAST_CHANGE_DATE_RESPONSE : analyzeUpdateDate((TaxiParkingsLastChangeDateResponse)response);break;//Пришла дата последнего обновления позиций
                    case Response.WORK_REPORT_RESPONSE : showReport((WorkReportResponse)response); break;//Показываем отчет по времени
                    case Response.TAXI_PARKINGS_RESPONSE2 :
                    case Response.TAXI_PARKINGS_RESPONSE : saveLoadedPositions((TaxiParkingsResponse)response);break;//Обрабатываем обновление списка парковок
                    case Response.UNREGISTER_ON_TAXI_PARKING_RESPONSE : unregisterParkingAnswer((UnRegisterOnTaxiParkingResponse)response);break;//Ответ на снятие с позиции
                    case Response.DRIVER_PARKING_POSITION_RESPONSE : analyzeDriverParkingPosition((DriverParkingPositionResponse)response);break;//Пришел пакет с инфой о позиции водителя
                    case Response.PPCSETTINGS_RESPONSE : savePPCSettings((PPCSettingsResponse)response); break; //Пришел пакт PPCSettings с настройками
                    case Response.SETTINGSXML_RESPONSE : saveXMLSettings((SettingsXML)response); break; //Пришел пакт с XML настройками
                    case Response.CALL_SIGNCHANGED_RESPONSE : doCallSignChanged((CallSignChangedResponse)response); break; //Заказ передан другому водителю
                    case Response.GET_ORDERS_RESPONSE : processOrders((GetOrdersResponse)response); break; //Обрабатываем пачку заказов от сервера
                    case Response.SQL_RESPONSE : doSaveTariffzone((SQLResponse)response); break; //Пришел ответ на запрос регионов
                    case Response.PREORDERS_RESPONSE: processPreOrders((PreOrdersResponse)response); break; //Пришел ответ на запрос предварительных заказов
                    case Response.CSBALANCE_RESPONSE: processCSBalance((GetCSBalanceAnswer)response); break;
                    case Response.DRIVER_MESSAGE_RESPONSE: processDriverMessageResponse((DriverMessageResponse)response); break; //Отображаем сообщение  
                    case Response.CANCEL_EFIR_ORDER: processCancelEfirOrder((CancelEfirOrder)response); break;
                    case Response.CLEAR_EFIR : processClearEfir((ClearEfir)response); break;
                    case Response.CHANGE_STATE : processChangeState((ChangeState)response); break;
                    case Response.REFUSE_PRELIMINARY_ORDER_ANSWER : processRefusePreliminaryOrder((RefusePreliminaryOrderAnswer)response); break;
                }
            }
        }
        else if (code==2)
        {
            destroyApp(false);
        }
        else if (code==0)//ошибка соединения
        {              
            //Сбрасываем соединенеи
            resetConnection(true);

            //Если стоит флаг автовхода - то входим
            if (Settings.getSettings().isAutoEnter())
            {
                DynamicForm form =  ViewManager.getViewManager().getForm("main_menu");
                if (form != null)
                {
                    form.show();
                }

                doEnter();
            }
            else
            {
                //Выводим сообщение
                String errorString;
                errorString = Utils.byteToString(data);
                showAlert("", parameters.getValue(errorString), AlertType.ERROR, ViewManager.getViewManager().getForm("main_menu"), false);

                //Запускаем таймер реконекта
                StartReconnectTimer();
            }
        }
    }

    private void processCSBalance(GetCSBalanceAnswer response)
    {
        showAlert("", "Ваш баланс: " + response.getSum() + " грн." ,AlertType.INFO,ViewManager.getViewManager().getForm("main_form"));
    }
    
    private void pingAnswer()
    {
        byte[] data;
	//Генерируем данные для ответа на пинг
	data = parameterBuilder.createPingAnswer();
	connection.send(data);
    }

    private void showServerError()
    {
        showAlert("", "Приносим свои извинения, но произошла ошибка на сервере",AlertType.ERROR,ViewManager.getViewManager().getForm("main_menu"));
    }

    private void loginResponse(LoginResponse responce)
    {
        if (responce.getAnswer().equals("AllIsInOrder"))
	{
            //Меняем название первого пункта
            ActionManager.getManager().setText("main_change", "Главное меню");

            //Убираем пункт "Очистка RMS"
            lockClearRMS();
            
            //Запускаем поток проверки наличия соединенеия
            connectionChecker = new ConnectionChecker(this,this,connection);

            //Сохраняем пришедшие данные
            rd.stringToGuid(responce.getGUID());
            rd.setSrvID(responce.getSrvID());
            rd.setPeopleID(responce.getPeopleID());

            //Отображаем меню
            showMainForm();

            //Запускаем таймер обновления предзаказов
            startPreordersUpdateTimer();
            
            //Ставим водителя на смену и делаем запрос времен T1,T2 и T3
            byte[] data,body;
            //Генерируем данные запроса для постановки водителя на смену
            body = parameterBuilder.createBodyRegisterOnRelay(Settings.getSettings().getNick(),true,rd.getPeopleID());
            data = parameterBuilder.createSrvTransfereData("PointToGroup",rd.getSrvID(), 2, rd.getGUID(),true,body);
            connection.send(data);
            
            if (BuildInfo.DISP_ORDER_NUMBER >= 4) {
                //Software version
                body = parameterBuilder.createVersionDeviceSoftware("2", BuildInfo.DEVICE_SOFTWARE_VERSION, rd.getPeopleID()); //"2" - is for Java
                data = parameterBuilder.createSrvTransfereData("PointToGroup",rd.getSrvID(), 2, rd.getGUID(),true,body);
                //Отправляем данные
                connection.send(data);
                
                //Генерируем данные запроса настроек
                body = parameterBuilder.createBodyGetPPCSettingsXML(rd.getPeopleID());
                data = parameterBuilder.createSrvTransfereData("PointToGroup",rd.getSrvID(), 2, rd.getGUID(),true,body);
                //Отправляем данные
                connection.send(data);
            } else {
                //Генерируем данные запроса времен T1,T2 и T3
                body = parameterBuilder.createBodyGetPPCSettings(rd.getPeopleID());
                data = parameterBuilder.createSrvTransfereData("PointToGroup",rd.getSrvID(), 2, rd.getGUID(),true,body);
                //Отправляем данные
                connection.send(data);
            }
            //Чистим данные
            data = null;
            body = null;
            
            //Запрос состояния водителя
            getDriverState();
        }
        else
        {
            //Если соединение небыло установлено
            if (connection!=null)
            {
                connection.disconnect();
            }
            connection = null;
            showAlert("",parameters.getValue(responce.getAnswer()),AlertType.ERROR,ViewManager.getViewManager().getForm("main_menu"));
        }
    }

    //Запуск таймера обновления предзаказов
    private void startPreordersUpdateTimer()
    {         
        //Если таймер запущен - останавливаем
        if (preordersUpdateTimer != null)
        {
            try
            {
                preordersUpdateTimer.cancel();
            }catch(Exception ex){}
        }
        
        //Запускаем обновление количества пред. заказов
        int period = Settings.getSettings().getPreordersUpdatePeriod() * 60 * 1000; //Сразу приводим к миллисекундам, т.к. в настройках в минутах
        if (period > 0)
        {
            preordersUpdateTimer = new Timer();
            preordersUpdateTimer.schedule(new TimerTask() 
            {
                public void run()
                {
                    requestPreliminaryOrdersUpdate();
                }
            }, period, period);
        } 
    }
    
    private boolean requestPreliminaryOrdersUpdate()
    {      
        if (connection.isOpen())
        {
            //Формируем запрос
            byte[] body = parameterBuilder.createReqPreOrders(rd.getPeopleID());
            byte[] data = parameterBuilder.createSrvTransfereData("PointToGroup",rd.getSrvID(), 2, rd.getGUID(),true,body, PN_UPDATE_PREORDERS_COUNT);
        
            //Отправляем данные
            return connection.send(data);
        }
        
        return false;
    }
    
    private void saveXMLSettings(SettingsXML response) {
        if (response.settingsData != null) {
            rd.setT1(response.settingsData.T1);
            rd.setT2(response.settingsData.T2);
            rd.setT3(response.settingsData.T3);
            rd.setCheckNoSubOrderForClose(response.settingsData.checkNoSubOrderForClose);

            connectionChecker.setMaxSendCoordsTime(response.settingsData.maxSendCoordsTime);

            //Устанавливаем количество возможных взятых заказов
            if (response.settingsData.maxOrdersCount != -1)
            {
                orderManager.setMaxOrdersCount(response.settingsData.maxOrdersCount);
            }

            //Чистим стоянкие если не совпал класс водителя
            if (Settings.getSettings().getAutoTariffClassUID() != response.settingsData.autoTariffClassUID)
            {       
                Settings.getSettings().setAutoTariffClassUID(response.settingsData.autoTariffClassUID);
                Settings.getSettings().setLastUpdate(0);
            }

            //Обновляем версию
            if ((response.settingsData.javaVersion != null) && (response.settingsData.link != null))
            {
                try
                {
                    double version = Double.parseDouble(response.settingsData.javaVersion);
                    String temp = getAppProperty("MIDlet-Version");
                    double selfVersion = Double.parseDouble(temp);

                    if (selfVersion < version)
                    {
                        //Обнуляем соединение
                        try
                        {
                            connectionChecker.stop();
                            connection.disconnect();
                        }
                        catch(Exception e){}
                        connectionChecker = null;
                        connection = null;
                        System.gc();

                        rd.setNewVersionLink(response.settingsData.link);

                        //Выводим сообщение
                        showLoadForm();
                    }
                }catch(Exception e){}
            }
        }
        
        //Дозапрашиваем заказы, если их нет
        requestOrders();
        //Запрашиваем эфир
        sendRequestAir();
    }
    
    private void savePPCSettings(PPCSettingsResponse responce)
    {        
        rd.setT1(responce.getT1());
        rd.setT2(responce.getT2());
        rd.setT3(responce.getT3());
        rd.setCheckNoSubOrderForClose(responce.isCheckNoSubOrderForClose());
        
	connectionChecker.setMaxSendCoordsTime(responce.getMaxSendCoordsTime());
        
        //Устанавливаем количество возможных взятых заказов
        if (responce.getMaxOrdersCount() != -1)
        {
            orderManager.setMaxOrdersCount(responce.getMaxOrdersCount());
        }
        
        //Чистим стоянкие если не совпал класс водителя
        if (Settings.getSettings().getAutoTariffClassUID() != responce.getAutoTariffClassUID())
        {       
            Settings.getSettings().setAutoTariffClassUID(responce.getAutoTariffClassUID());
            Settings.getSettings().setLastUpdate(0);
        }
        
        //Обновляем версию
        if ((responce.getJavaVersion() != null) && (responce.getLink() != null))
        {
            try
            {
                double version = Double.parseDouble(responce.getJavaVersion());
                String temp = getAppProperty("MIDlet-Version");
                double selfVersion = Double.parseDouble(temp);

                if (selfVersion < version)
                {
                    //Обнуляем соединение
                    try
                    {
                        connectionChecker.stop();
                        connection.disconnect();
                    }
                    catch(Exception e){}
                    connectionChecker = null;
                    connection = null;
                    System.gc();

                    rd.setNewVersionLink(responce.getLink());

                    //Выводим сообщение
                    showLoadForm();
                }
            }catch(Exception e){}
        }

        //Дозапрашиваем заказы, если их нет
        requestOrders();
        //Запрашиваем эфир
        sendRequestAir();
    }

    private void relayCommunicationAnswer(RelayCommunicationResponse response)
    {
        //Снятие регистрации
	if (response.getRelayCommunicationType().equals("UnRegister"))
	{
            if (rd.isExitFlag())
            {
                doExitWithoutClosing();
            }
            else
            {
                //Сбрасываем соединение
                resetConnection(false);
                
                showAlert("", parameters.getValue(response.getRelayAnswerType()) ,AlertType.INFO,ViewManager.getViewManager().getForm("main_menu"));
            }
	}

	//неверный позывной
	if (response.getRelayCommunicationType().equals("Register")&&response.getRelayAnswerType().equals("InvalidCallSign"))
	{
            //Сбрасываем соединение
            resetConnection(false);

            showAlert("", "Вы ввели неверный позывной.Повторите ввод.",AlertType.ERROR, ViewManager.getViewManager().getForm("main_menu"));
	}
	//Временно нельязя регистрироваться на смене
	if (response.getRelayCommunicationType().equals("Register")&&response.getRelayAnswerType().equals("OutOfSeason"))
	{
            //Сбрасываем соединение
            resetConnection(false);

            //Выводим сообщение
            showAlert("", "Таймаут снятия со смены еще не прошел",AlertType.ERROR,ViewManager.getViewManager().getForm("main_menu"));
	}
        if (response.getRelayCommunicationType().equals("Register")&&response.getRelayAnswerType().equals("DriverIsBlocked"))
        {
            //Сбрасываем соединение
            resetConnection(false);

            //Выводим сообщение
            showAlert("", "Вы заблокированы и не можете стать на смену",AlertType.INFO,ViewManager.getViewManager().getForm("main_menu"));

            try
            {
                Thread.sleep(3000);
            }catch(Exception e){}

            destroyApp(true);
        }
    }

    private void resetConnection(boolean playAlert)
    {
        if (playAlert)
        {
            startMusic(0,"/disc.mid",false);
        }

        //Обнуляем соединение
        try
        {
            connectionChecker.stop();
            connection.disconnect();
        }
        catch(Exception e){}
        connectionChecker = null;
   //     connection = null;
        System.gc();
        //Меняем название первого пункта
        ActionManager.getManager().setText("main_change", "Вход");
    }

    public void actionTimeOut()
    {
        //Обнуляем таймер
        if (timer != null)
        {
            timer.cancel();
            timer = null;
            cancelTask = null;
        }

        //Сбрасываем соединенеи
        resetConnection(true);

        //Если стоит флаг автовхода - то входим
        if (Settings.getSettings().isAutoEnter())
        {
            DynamicForm form =  ViewManager.getViewManager().getForm("main_menu");
            if (form != null)
            {
                form.show();
            }

            doEnter();
        }
        else
        {
            //Выводим сообщение
            showAlert("","Удаленный сервер не отвечает.Попробуйте переподсоединиться", AlertType.ERROR, ViewManager.getViewManager().getForm("main_menu"));
        }
    }

    private void showArchivesMenu()
    {
        //Создаем меню если оно еще не создано
        if (archivesMenuList == null)
        {
            archivesMenuList = new ArchivesMenuList(orderManager.getCompletedOrderCount(), new FormAction()
            {
                public void commandAction(int commandID)
                {
                    switch (commandID)
                    {
                        case ArchivesMenuList.COMPLETED_ID : showArchiveOrdersList(Order.STATE_PERFORMED); break;
                        case ArchivesMenuList.CANCELLED_ID : showArchiveOrdersList(Order.STATE_CANCELLED); break;
                        case ArchivesMenuList.MISSED_ID : showArchiveOrdersList(Order.STATE_MISSED); break;
                        case ArchivesMenuList.REPORT_ID : showReportForm();break;
                        case ArchivesMenuList.BACK_ID : showMainForm(); break;
                    }
                }
            });
            
        }

        //Показываем меню
        setPrev(archivesMenuList);
        archivesMenuList.show();
    }

    private void showSubmenu()
    {
        DynamicForm form =  ViewManager.getViewManager().getForm("submenu");

        if (form != null)
        {
            actionManagerUpdate();

            setPrev(form);
            form.show();
        }
        else
        {
            showMainForm();
        }
    }

    private void doExit()//Функция отображения формы выхода
    {
        if (connection!=null&&connection.isOpen())
	{
            if (exitMenu==null)
            {
                exitMenu = new ExitMenu(new FormAction()
                {
                    public void commandAction(int commandID)
                    {
                        if (commandID == ExitMenu.EXIT_PAUSE_ID)
                        {
                            doExitWithClosing("EndRelay_pause");
                        }
                        else if (commandID == ExitMenu.EXIT_CLOSE_RELAY_ID)
                        {
                            doExitWithClosing("EndRelay");
                        }
                        else if (commandID == ExitMenu.EXIT_TEMPORARILY_ID)
                        {
                            doExitWithoutClosing();
                        }
                        else if (commandID == ExitMenu.BACK_ID)
                        {
                            //Возвращаемся в главное меню
                            showMainMenu();
                        }
                    }
                });
            }

            setPrev( exitMenu);
            exitMenu.show();
	}
	else
	{
            destroyApp(false);
	}
    }

    private void doExitWithClosing(String type)
    {
        //Если есть текущий заказ - не давать закрыть смену
	if (orderManager.currentOrder() != -1)
	{
            //Выводим сообщение
            showAlert("Вы не можете закрыть смену,т.к. у вас есть активный заказ.", AlertType.ERROR);
            return;
	}

        //Если закрываем смену - сбросить фильтр
        if (type.equals("EndRelay"))
        {
            //сохранить фильтр
            Settings.getSettings().setFilter(regionsFilter.getString(true));
        }

	byte[] closeData,body;
	//Генерируем данные для вылогинивания
	body = parameterBuilder.createPPCUnRegisterOnRelay(true,type,rd.getPeopleID());
	closeData = parameterBuilder.createSrvTransfereData("PointToGroup",rd.getSrvID(), 2, rd.getGUID(),true,body);

	//Показываем форму загрузки
	showProgressForm(TIMEOUT);

        rd.setExitFlag(true);

	orderManager.clear();

	//Отправляем данные
	connection.send(closeData);
    }

    private void doExitWithoutClosing()
    {
        byte[] data;
	//Генерируем данные для вылогинивания
	data = parameterBuilder.createLogout(rd.getSrvID(), rd.getGUID());
	showProgressForm(TIMEOUT);
	connection.sendLogout(data);
    }

    private void createOptions()
    {
        if (optionsForm == null)
        {
            optionsForm = new OptionsForm(new FormAction()
            {
                public void commandAction(int commandID)
                {
                    if (commandID == OptionsForm.SAVE_ID)
                    {
                        //Сохраняем настройки
                        Settings.getSettings().saveOptions();

                        //Показываем основное меню
                        showMainMenu();
                    }
                    else if (commandID == OptionsForm.BACK_ID)
                    {
                        //Показываем основное меню
                        showMainMenu();
                    } 
                    else if (commandID == OptionsForm.LOG_ID)
                    {
                        showLogForm();
                    }
                    else if (commandID == OptionsForm.DELETE_ORDERS_ID)
                    {
                        try
                        {
                            orderManager.deleteTakenOrders();
                        }catch(Exception e){}
                    }
                    else if (commandID == OptionsForm.CLEAR_RMS_ID)
                    {
                        doClearRMS();
                    }
                }
            });
        }
    }

    private void showLogForm()
    {
        if (logForm == null)
        {
            logForm = new LogForm(new FormAction()
            {
                public void commandAction(int commandID)
                {
                    if (commandID == LogForm.BACK_ID)
                    {
                        showOptions();
                    }
                }
            });
        }

        logForm.setText(LOG_STR);

        logForm.show();
    }

    private void showOptions()
    {
        if (passwordFormSettings != null)
        {
            String enteredPassword = convertToMD5(passwordFormSettings.getPassword());
            if (!enteredPassword.equals(Settings.getSettings().getOptionsPassword()))
            {
                //Показываем сообщение о неверном пароле
                showAlert("Введен неверный пароль",AlertType.ERROR);
                return;
            }
        }

        //Создаем форму
        createOptions();

        //Отображаем
        setPrev(optionsForm);
        optionsForm.show();
    }

    private void analyzeUpdateDate(TaxiParkingsLastChangeDateResponse response)
    {
        try
        {
            positionManager.setLastChange(response.getLastChange());
            checkForPositionUpdates();
	}catch(Exception e){}
    }

    private void checkForPositionUpdates()
    {
        if (positionManager.getLastChange()==0)//Если дата последнего обновления не загружена - грузим
        {
            byte[] data,body;
            //Генерируем данные
            body = parameterBuilder.createBodyGetTaxiParkingsLastChangeDate(rd.getPeopleID());
            data = parameterBuilder.createSrvTransfereData("PointToGroup",rd.getSrvID(), 2, rd.getGUID(),true,body);
            //Показываем форму загрузки
            showProgressForm(TIMEOUT);
            //Отправляем данные
            connection.send(data);
        }
        else
        {
            if (Settings.getSettings().getLastUpdate() < positionManager.getLastChange())//Если нужно загрузить стоянки
            { 
                //Загружаем списки секторов
                byte[] data,body,data1,total;
                //Генерируем данные
                body = parameterBuilder.createBodyGetTaxiParkings(rd.getPeopleID());
                data = parameterBuilder.createSrvTransfereData("PointToGroup",rd.getSrvID(), 2, rd.getGUID(),true,body);
                data1 = createTariffzoneRequest();
                total = new byte[data.length + data1.length];
                int index = 0;

                for (int i = 0; i < data.length; ++i)
                {
                    total[index++] = data[i];
                }
                for (int i = 0; i < data1.length; ++i)
                {
                    total[index++] = data1[i];
                }

                rd.setShowFilterForm(false);

                //Показываем форму загрузки
                showProgressForm(TIMEOUT*3);
                //Отправляем данные
                connection.send(total);
            }
            else
            {
                //ЗАпрашиваем статистику по стоянкам
                getStatistic();
            }
        }
    }

    private void getStatistic()//Запрос количества водителей на стоянках
    {
        byte[] data,body;
	//Генерируем данные
	body = parameterBuilder.createGetTaxiParkingStatistic(rd.getPeopleID());
	data = parameterBuilder.createSrvTransfereData("PointToGroup",rd.getSrvID(), 2, rd.getGUID(),true,body);
	//Показываем форму загрузки
	showProgressForm(TIMEOUT);
	//Отправляем данные
	connection.send(data);
    }

    private void saveLoadedPositions(TaxiParkingsResponse response)
    {
	//Удаляем все из positionManager
	positionManager.clear();
	//Добавляем новые позиции
 
	for (int i = 0;i < response.count(); ++i)
	{
            positionManager.addPosition(response.getPosition(i));
	}

	//Сохраняем список позиций в rms
	positionManager.save();
	//Сохраняем время последнего обновления
	try{
            Thread.sleep(1000);
	}catch(Exception e){}
	Settings.getSettings().setLastUpdate(response.getLastUpdate());
	checkForPositionUpdates();
    }
    
    private void showStateForm()
    {
        //Создаем форму
	if (statisticRegionList == null)
	{
            statisticRegionList = new RegionList(new FormAction()
            {
                public void commandAction(int commandID)
                {
                    if (commandID == RegionList.CHOSE_ID)
                    {
                        CellItem selectedRegion = statisticRegionList.getSelectedItem();
                        //Если нет раенов - ничего не делаем
                        if (selectedRegion != null)
                        {
                            //Выводим форму раена
                            showStateParkingsList(selectedRegion.getText());
                        } 
                    }
                    else if (commandID == RegionList.BACK_ID)
                    {
                        showSubmenu();
                    }
                }
            });
	}

        updateStatisticRegionList();

	setPrev( statisticRegionList);
	statisticRegionList.show();
    }


    private void updateStatisticRegionList()
    {
        if (statisticRegionList != null)
        {
            //Удаляем все предыдущее
            statisticRegionList.clear();

            //Выводим новые
            String[] regions = positionManager.getRegions();
            for (int i = 0; i < regions.length; ++i)
            {
                statisticRegionList.add(regions[i]);
            }
        }
    }

    private void showSetParkingForm(TaxiParkingStatisticResponse response)//Отображение формы регистрации в секторе
    {
        //Обновляем количество машин на стоянке
        positionManager.updateCarsCount(response.getStatistics());

        //Если это ответ на запрос о текущем состоянии
        if (rd.isIsStateRequest())
        {
            rd.setIsStateRequest(false);
            loadCurrentState();
            return;
        }

        if (rd.isIsUpdating())
        {
            rd.setIsUpdating(false);
            updateParkingForm(rd.getShownRegion());
            showPrevForm();
        }
        else
        {
            //Отображаем список раенов
            showRegionList();
        }
    }

    private void showRegionList()
    {
       //Отображаем форму
	if (regionList == null)
	{

            regionList = new RegionList(new FormAction()
            {
                public void commandAction(int commandID)
                {
                    if (commandID == RegionList.CHOSE_ID)
                    {
                        CellItem selectedRegion = regionList.getSelectedItem();
                        //Если нет раенов - ничего не делаем
                        if (selectedRegion != null)
                        {
                            //Выводим форму раена
                            showParkingList(selectedRegion.getText());
                        } 
                    }
                    else if (commandID == RegionList.BACK_ID)
                    {
                        showSubmenu();
                    }
                }
            });
	}

        //Обновляем список раенов
        updateRegionList();

	setPrev(regionList);
	regionList.show();
    }

    private void updateRegionList()
    {
        if (regionList != null)
        {
            //Удаляем все предыдущее
            regionList.clear();

            //Выводим новые
            String[] regions = positionManager.getRegions();
            for (int i=0;i<regions.length;++i)
            {
                regionList.add(regions[i]);
            }
        }
    }

    private void parkingAnswer(RegisterOnTaxiParkingResponse response)
    {
        if (response.getResult().equals("Done"))
	{
            //Вывод сообщения
            String numberInQueue = "";
            if (response.getNumberInQueue() != -1)
            {
                numberInQueue = Integer.toString(response.getNumberInQueue());
            }
            TimerService.getTimerService().setDriverPositionInfo(numberInQueue, response.getParkingName());
            showAlert("","Стоянка: " + response.getParkingName() + ", " + numberInQueue,AlertType.INFO,ViewManager.getViewManager().getForm("main_form")); 
	}
	if (response.getResult().equals("ParkingNotFound"))
	{
            showAlert("Ошибка", "Стоянка не была найдена в базе данных",AlertType.ERROR,ViewManager.getViewManager().getForm("main_form"));
	}
	if (response.getResult().equals("Error"))
        {
            showAlert("Ошибка", "Ошибка регистрации на стоянке",AlertType.ERROR,ViewManager.getViewManager().getForm("main_form"));
        }
    }

    private void unregisterParkingRequest()
    {
        if (unregisterConfirmation == null)
        {
            unregisterConfirmation = new UnregisterConfirmation(new FormAction()
            {
                public void commandAction(int commandID)
                {
                    if (commandID == UnregisterConfirmation.OK_ID)
                    {
                        unregisterParking();
                    }
                    else if (commandID == UnregisterConfirmation.CANCEL_ID)
                    {
                        showPrevForm();
                    }
                }
            });
        }

        unregisterConfirmation.show();
    }
    
    private void setChangeDriverStateText(String currentState) {
        //Ставим инвертное значение, т.к. эт означение  - на которое будет состояние менятся при смене данного пункта
        if (RuntimeData.DRIVER_STATE_FREE.equals(currentState)) {
            ActionManager.getManager().setText("state_text_change", "Занят");
        } else {
            ActionManager.getManager().setText("state_text_change", "Свободен");
        }
    }
    
    private void processRefusePreliminaryOrder(RefusePreliminaryOrderAnswer responce) {
        Order order = orderManager.getPreOrder(responce.orderId);
        if (order != null) {
            order.setIsDriverSigned(responce.isDriverSigned);
            order.setSigned(responce.signed);
        }
//        System.out.println("refuse=" + responce.signed + ", " + responce.isDriverSigned);
    }
    
    private void processChangeState(ChangeState response) {
        if (!rd.getDriverState().equals(response.getState())) {
            rd.setDriverState(response.getState());
            
            setChangeDriverStateText(rd.getDriverState());
        }
    }

    private void changeState() {
        byte[] data,body;
	//Генерируем данные
	body = parameterBuilder.createChangeDriverState(rd.getDriverReverseState() , 0, rd.getPeopleID());
	data = parameterBuilder.createSrvTransfereData("PointToGroup",rd.getSrvID(), 2, rd.getGUID(),true,body);
        
	//Отправляем данные
	connection.send(data);
    }
    
    private void getDriverState() {
        byte[] data,body;
	//Генерируем данные
	body = parameterBuilder.createGetDriverState(rd.getPeopleID());
	data = parameterBuilder.createSrvTransfereData("PointToGroup",rd.getSrvID(), 2, rd.getGUID(),true,body);
        
	//Отправляем данные
	connection.send(data);    
    }
    
    private void getBalance()
    {
        byte[] data,body;
	//Генерируем данные
	body = parameterBuilder.createGetBalanceData(rd.getPeopleID());
	data = parameterBuilder.createSrvTransfereData("PointToGroup",rd.getSrvID(), 2, rd.getGUID(),true,body);
	//Показываем форму загрузки
	showProgressForm(TIMEOUT);
	//Отправляем данные
	connection.send(data);        
    }
    
    private void unregisterParking()
    {
	byte[] data,body;
	//Генерируем данные
	body = parameterBuilder.createUnRegisterOnTaxiParking(rd.getPeopleID());
	data = parameterBuilder.createSrvTransfereData("PointToGroup",rd.getSrvID(), 2, rd.getGUID(),true,body);
	//Показываем форму загрузки
	showProgressForm(TIMEOUT);
	//Отправляем данные
	connection.send(data);
    }

    private void unregisterParkingAnswer(UnRegisterOnTaxiParkingResponse response)
    {   
	if (response.getUnregistered() == 1)
	{
            TimerService.getTimerService().resetDriverPositionInfo();
            showAlert("", "Удачи по городу" ,AlertType.INFO,ViewManager.getViewManager().getForm("main_form"));
	}
	else
	{
            showAlert("", "Водиель небыл снят со стоянки",AlertType.ERROR,ViewManager.getViewManager().getForm("main_form"));
	}
    }

    private boolean needShowOldOrder() {
        if (menuType == FunctionMenu.KIROVOGRAD_TYPE)
        {
            Form currentForm = com.sun.lwuit.Display.getInstance().getCurrent();
            if ((currentForm instanceof OrderDetails) || (currentForm instanceof EfirOrderDetails) || 
                (currentForm instanceof PreOrderDetails) || (currentForm == waitForm)) {
                return false;
            } else {
                return true;
            }    
        } else {
            return true;
        }
    }
    
    private void newOrder(OrderResponse response)//Обработка пакета,описывающего заказ
    {

        //Проверяем, попадает ли заказ под фильтр
        if (response.getOrderType().equals("FindDriver3") && regionsFilter.outOfFilter(response.getOrder().getRegion()))
        {
            return;
        }    

        //Запоминаем состояние заказа до обработки в менеджере
        int stateBefore = orderManager.getOrderState(response.getOrder().getOrderID());
        int currentOrderId = orderManager.currentOrder();

        //Обрабатываем новый заказ
        try
	{
            orderManager.processIncomingOrder(response);
	}
	catch(Exception e)
	{
	}

        if (response.getFolder().equals("Невыполненный")||response.getFolder().equals("Корзина"))
	{
            if (stateBefore == Order.STATE_NEW)
            {
                updateOrders();
                return;
            }

            //Играем музыку
            if (!Settings.getSettings().isSwitchOffMusic())
            {
                int selectedItem = Settings.getSettings().getVoiceRington();
                switch (selectedItem)
                {
                    case(0): startMusic(0,"/badorder.mid",true); break; 
                    case(1): startMusic(0,"/badorder.amr",true); break;
                    case(2): startMusic(0,"/badorder_v.amr",true); break;
                    default: startMusic(0,"/badorder.mid",true); break;
                }
            }
  
            //Выводим сообщение
            int deletedOrderID = response.getOrder().getOrderID();

            //Сбрасываем таймер, если отменили текущий
            if (currentOrderId == deletedOrderID)
            {
                stopTimerAction();
            }

            //Запрашиваем эфир
            sendRequestAir();
            
            //Выводим отмененный заказ
            showCompletedOrder(deletedOrderID, "Заказ отменен");
            return;
	}

        //Помечаем заказ как выполненный
        if (response.getFolder().equals("Выполненный"))
        {
            //Играем музыку
            if ((!Settings.getSettings().isSwitchOffMusic()) && (Settings.getSettings().getYourOrderMelodyIndex() != 2))
            {
                if (Settings.getSettings().getYourOrderMelodyIndex() == 0)
                {
                    int selectedItem = Settings.getSettings().getVoiceRington();
                    switch (selectedItem)
                    {
                        case(0): startMusic(0,"/yourorder.mid",false); break;
                        case(1): startMusic(0,"/yourorder.amr",false); break;
                        case(2): startMusic(0,"/yourorder_v.amr",false); break;
                        default: startMusic(0,"/yourorder.mid",false); break;
                    }
		}
		else
                {
                    startMusic(1,Settings.getSettings().getYourOrderMediaFile(),false);
		}
            }
            
            //Выводим сообщение
            int ID = response.getOrder().getOrderID();
            showOldOrder(ID, "Статус заказа "); 

            return;
        }

        //Выводим сообщение о новом заказе
	if (response.getOrderType().equals("FindDriver1")||response.getOrderType().equals("FindDriver2")||response.getOrderType().equals("FindDriver3"))
	{
            //Если не подходит по цене
            if (orderManager.outOfSum(response.getOrder().getFare()))
            {
                return;
            }

            //Если заказ не из "Эфира" - выводим сообщение о полученном заказе
            if (!response.getOrderType().equals("FindDriver3"))
            {
                if (needShowOldOrder()) {
                    rd.setShownOrder(response.getOrder().getOrderID());
                    showOldOrder(rd.getShownOrder(), "Новый заказ");
                }
 
		//Запускаем музыку
		if ((!Settings.getSettings().isSwitchOffMusic()) && (Settings.getSettings().getNewOrderMelodyIndex() != 2))
		{
                    if (Settings.getSettings().getNewOrderMelodyIndex() == 0)
                    {
                        int selectedItem = Settings.getSettings().getVoiceRington();
                        switch (selectedItem)
                        {
                            case(0): startMusic(0,"/neword.mid",false); break;
                            case(1): startMusic(0,"/neword.amr",false); break;
                            case(2): startMusic(0,"/neword_v.amr",false); break;
                            default: startMusic(0,"/neword.mid",false); break;
                        }
                    }
                    else
                    {
                        startMusic(1, Settings.getSettings().getNewOrderMediaFile(), false);
                    }
		}
            }
            else
            {
                //Запускаем музыку
		if (!Settings.getSettings().isSwitchOffMusic())
		{
                    switch (Settings.getSettings().getVoiceRington())
                    { 
                        case(0): startMusic(0,"/efirord.mid",false); break;
                        case(1): startMusic(0,"/efirord.amr",false); break;
                        case(2): startMusic(0,"/efirord_v.amr",false); break;
                        default: startMusic(0,"/efirord.mid",false); break;
                    }
                    lastEfirMusicReplay = System.currentTimeMillis();
		}
            }
	}

        //Выводим сообщение об оформленном заказе
	if ((response.getOrderType().equals("SendedByDispatcherFromGetFolder"))||(response.getOrderType().equals("SendedByDispatcher")))
	{
            //Устанавливаем ИД текущего заказa
            rd.setShownOrder(response.getOrder().getOrderID());

            //Если заказ новый на выполнение - запускаем таймер
            if (stateBefore != Order.STATE_PERFORMING && orderManager.getOrderState(response.getOrder().getOrderID()) == Order.STATE_PERFORMING
                 && menuType == FunctionMenu.CHERNOVTSI_TYPE)
            {
                TimerService.getTimerService().startTimer(rd.getGivingTime(response.getOrder().getOrderID()));

                createFunctionMenu();
                functionMenu.startTimerEvent();
            }

            //Выводим сообщение
            showOldOrder(rd.getShownOrder(), "Заказ оформлен,можете выполнять");

            //Запускаем музыку
            if ((!Settings.getSettings().isSwitchOffMusic())&&(Settings.getSettings().getYourOrderMelodyIndex() != 2))
            {
                if (Settings.getSettings().getYourOrderMelodyIndex() == 0)
                {
                    int selectedItem = Settings.getSettings().getVoiceRington();
                    switch (selectedItem)
                    {
                        case(0): startMusic(0,"/yourorder.mid",false); break;
                        case(1): startMusic(0,"/yourorder.amr",false); break;
                        case(2): startMusic(0,"/yourorder_v.amr",false); break;
                        default: startMusic(0,"/yourorder.mid",false); break;
                    }
		}
		else
                {
                    startMusic(1,Settings.getSettings().getYourOrderMediaFile(),false);
		}
            }
	}
    }

    private void stopTimerAction()
    {
        //Удаляем таймер
        TimerService.getTimerService().stopTimer();
        
        //Уведомляем функциональное меню
        createFunctionMenu();
        functionMenu.stopTimerEvent();
    }

    public void reconnectAction()
    {
//        synchronized(this)
//	{
//            if (code==2)
//            {
		byte[] data,body;
                //Генерируем данные
                body = parameterBuilder.createBodyUpdateJavaConnectionState(rd.getPeopleID());
                data = parameterBuilder.createSrvTransfereData("PointToGroup",rd.getSrvID(), 2, rd.getGUID(),true,body);
		//Отправляем данные
                connection.send(data);
                
//		if (!connection.send(data))
//		{
//                    startMusic(0,"/disc.mid",false);
//
//			//Обнуляем соединение
//			try
//			{
//                            connectionChecker.stop();
//                            connection.disconnect();
//			}
//			catch(Exception e){}
//			connectionChecker = null;
//			connection = null;
//			System.gc();
//
//                        StopReconnectTimer();
//
//			//Генерируем данные для залогинивания
//			data = parameterBuilder.createLogin(255,Settings.getSettings().getLogin(),Settings.getSettings().getPassword(),true);
//			showProgressForm(TIMEOUT);
//			connection = new Connection(Settings.getSettings().getServerIP(),data,this);
//		}
//            }
//        }
    }

    private void StopReconnectTimer()
    {
        if (reconnectTimer != null)
        {
            reconnectTimer.cancel();
        }
        reconnectTimer = null;
    }

    private void StartReconnectTimer()
    {
        reconnectTimer = new Timer();
        reconnectTimer.schedule(new TimerTask(){ public void run(){doEnter();}}, 10000);
    }

    public void orderAction()
    {
        updateOrders();
    }

    private void updateOrders()
    {
	//Удаляем старые заказы
	orderManager.autoClear(rd.getT1(),rd.getT2(),rd.getT3());
	//Обновляем количество заказов
        actionManagerUpdate();

        if (archivesMenuList != null)
        {
            archivesMenuList.resetCount(orderManager.getCompletedOrderCount());
        }
        
	//Обновляем список новых заказов
	setEfirOrdersList();
	//Обновляем список старых заказов
	setOldOrdersList();
        //Обновляем список входящих заказов
        setIncomingOrdersList();
        //обновляем список моих заказов
        setMyOrdersList();

        //Обновляем время последнего обновления нтерфейса
        if (connectionChecker != null) {
            connectionChecker.updateLastInterfaceUpdateTime();
        }
        
        long currentTime = System.currentTimeMillis();
        if ((currentTime - lastRepaint) > MIN_REPAINT_PERIOD) {
            //Обновляем формы отображения деталей заказов
            if (orderDetails != null && orderDetails.isVisible()) {
                //Устанавливаем текст
                orderDetails.setText(orderManager.getOrderDetails(rd.getShownOrder(),false, "").getText());

                orderDetails.repaint();
                //orderDetails.invalidate();
                //showNewOrder(rd.getShownOrder());
            } else if (orderOldDetails != null && orderOldDetails.isVisible()) {
                //Получаем детали заказа
                OrderManager.OrderDatails details = orderManager.getOrderDetails(rd.getShownOrder(),false, "");

                //Устанавливаем команды
                if (!details.isError())
                {
                    orderOldDetails.setCommands(true, details.getIsNew(), (orderManager.currentOrder() == rd.getShownOrder()));
                }
                else
                {
                    orderOldDetails.setCommands(false, false, false);
                }

                //устанавливаем текст
                orderOldDetails.setText(details.getText());

                orderOldDetails.repaint();
                //orderOldDetails.invalidate();
                //showOldOrder(rd.getShownOrder(),"");
            }
            
            lastRepaint = currentTime;
        }
    }

    private void setEfirOrdersList()
    {
        if (efirOrdersList != null)
	{
            synchronized(efirOrdersList)
            {
                //Запоминаем ИД текущего выбранного заказа
                int oldSelectedOrderId;
                CellItem item = efirOrdersList.getSelectedItem();
                if (item != null)
                {
                    oldSelectedOrderId = item.getId();
                }
                else
                {
                    oldSelectedOrderId = -1;
                }

                //Удаляем старые данные
                efirOrdersList.clear();

                CellItem oldItem = null;

                //Заполняем данными
                CellItem[] arr = orderManager.getOrdersLis();
                for (int i = 0; i < arr.length; i++)
                {
                    if (arr[i].getId() == oldSelectedOrderId)
                    {
                        oldItem = arr[i];
                        efirOrdersList.add(oldItem);
                    }
                    else
                    {
                        efirOrdersList.add(arr[i]);
                    }
                }
                
                //Если остался текущий заказ - делаем его выбранным
                if (oldItem != null)
                {
                    efirOrdersList.setSelectedItem(oldItem);
                }
                else //if (efirOrdersList.size() > 0)
                {
                    efirOrdersList.unselectAll();
                }
            }
        }
    }

    private void startMusic(int type,String fileName,boolean replay)
    {
        //Если player существует,то пытаемся остановить звук
	stopMusic();


	//Запускаем новую музыку
	if (type==0)
	{
            //Мелодия по умолчанию
            try
            {
                is = getClass().getResourceAsStream(fileName);
		if (fileName.endsWith(".wav"))
                {
                    player = Manager.createPlayer(is,"audio/X-wav");
		}
		else if (fileName.endsWith(".amr"))
		{
                    player = Manager.createPlayer(is,"audio/amr");
		}
		else
		{
                    player = Manager.createPlayer(is,"audio/midi");
		}
		player.realize();
		//Изменяем громкость
		VolumeControl vc = null;
		try
		{
                    vc = (VolumeControl)player.getControl("VolumeControl");
		}catch(Exception e){}
		if(vc != null)
		{
                    vc.setLevel(20 * Settings.getSettings().getVolumeLevel());
		}
                if (replay)
                {
                    player.setLoopCount(-1);
                }
                else
                {
                    player.setLoopCount(1);
                }
		player.start();
            }catch(Exception e){}
        }
	else
	{
            try
            {
                player = Manager.createPlayer("file:///"+fileName);
                player.realize();
                //Изменяем громкость
                VolumeControl vc = null;
                try
                {
                        vc = (VolumeControl)player.getControl("VolumeControl");
                }catch(Exception e){}
                if(vc != null)
                {
                        vc.setLevel(20 * Settings.getSettings().getVolumeLevel());
                }
                if (replay)
                {
                    player.setLoopCount(-1);
                }
                else
                {
                    player.setLoopCount(1);
                }
                player.start();
            }catch(Exception e){}
	}
    }

    private void stopMusic()
    {
        if (is!=null)
	{
            try
            {
                is.close();
                is = null;
            }catch(Exception e){}
	}
	if (player!=null)
	{
            try
            {
                player.stop();
            }catch(Exception e){}
            try
            {
                //player.deallocate();
		player.close();
                player = null;
            }catch(Exception e){}
	}
    }

    private void createPreOrders()
    {
        if (preOrdersList == null)
        {
            preOrdersList = new OrdersList("Предварительные заказы", new FormAction()
            {
                public void commandAction(int commandID)
                {
                    switch (commandID)
                    {
                        case OrdersList.BACK_ID: showMainForm(); break;
                        case OrdersList.SHOW_ID:
                                CellItem item = (CellItem)preOrdersList.getSelectedItem();
                                if (item != null)
                                {
                                    showPreOrderDetails(item.getId());
                                }
                            break;
                    }
                }
            });
        }
    }

    private void createPreOrderDetails()
    {
        if (preOrderDetails == null)
        {
            preOrderDetails = new PreOrderDetails(new FormAction()
            {
                public void commandAction(int commandID)
                {
                    if (commandID == PreOrderDetails.SIGN_ID) {
                        signPreOrder();
                    } else if(commandID == PreOrderDetails.UNSIGN_ID) {
                        unsignPreOrder();
                    } else if (commandID == PreOrderDetails.BACK_ID) {
                        showPreOrders();
                    }
                }
            });
        }
    }

    private void unsignPreOrder() {
        //Если нет такого заказа - выходим
        if (rd.getCurrentPreOrderId() == -1)
        {
            return;
        }
        
        //Формируем данные для заявки
	byte[] data,body;
	body = parameterBuilder.createRefusePreliminaryOrder(rd.getCurrentPreOrderId(),Settings.getSettings().getNick(),rd.getPeopleID());
	data = parameterBuilder.createSrvTransfereData("PointToGroup",rd.getSrvID(), 2, rd.getGUID(),true,body);
        //Отправляем заявку
	connection.send(data);

        //Отображаем сообщение
        showAlert("", "Запрос отправлен", AlertType.INFO, ViewManager.getViewManager().getForm("main_form"));
    }
    
    private void signPreOrder()
    {
        //Если нет такого заказа - выходим
        if (rd.getCurrentPreOrderId() == -1)
        {
            return;
        }

        //Формируем данные для заявки
	byte[] data,body;
	body = parameterBuilder.createSignPreliminaryOrder(rd.getCurrentPreOrderId(),Settings.getSettings().getNick(),rd.getPeopleID());
	data = parameterBuilder.createSrvTransfereData("PointToGroup",rd.getSrvID(), 2, rd.getGUID(),true,body);
        //Отправляем заявку
	connection.send(data);

        //Отображаем сообщение
        showAlert("", "Заявка отправлена", AlertType.INFO, ViewManager.getViewManager().getForm("main_form"));
    }

    private void showPreOrderDetails(int id)
    {
        //Создаем форму если надо
        createPreOrderDetails();        

        //Обновляем форму
        Order details = orderManager.getPreOrder(id);
        if (details == null)
	{
            rd.setCurrentPreOrderId(-1);
            preOrderDetails.setText(null);
            preOrderDetails.setEmptyCommands();
	}
	else
        {
            rd.setCurrentPreOrderId(id);
            preOrderDetails.setText(details.getPreOrderDetails());
            preOrderDetails.setCommands(details.isDriverSigned());
        }

        //Отображаем форму
        setPrev( preOrderDetails);
	preOrderDetails.show();
    }
    
    private void createEfirOrdersList()
    {        
        if (efirOrdersList == null)
        {
            efirOrdersList = new EfirOrdersList(new FormAction()
            {
                public void commandAction(int commandID)
                {
                    if (commandID == EfirOrdersList.SHOW_ID)
                    {
                        CellItem item = efirOrdersList.getSelectedItem();
                        if (item != null)
                        {
                           
                            rd.setShownOrder(item.getId());
                            showNewOrder(rd.getShownOrder());
                        }
                    }
                    else if (commandID == EfirOrdersList.TEN_MINUTES_ID)
                    {
                        if (!Settings.getSettings().isTakeOrder())
                        {
                            return;
                        }

                        CellItem item = efirOrdersList.getSelectedItem();
                        if (item != null)
                        {
                            //Устанавливаем текущий заказ
                            rd.setShownOrder(item.getId());

                            //Берем заказ
                            if (menuType == FunctionMenu.CHERNOVTSI_TYPE)
                            {
                                //Пытаемся взять заказ
                                doGetOrder();
                            }
                            else
                            {
                                if (canGetTenMinutesOrder()) {
                                    gettingOrder(ViewManager.getViewManager().getTenMinutesText());
                                    lastGetTenTime = System.currentTimeMillis();
                                } else {
                                    showAlert("Вы временно не можете брать новый заказ!", AlertType.ERROR);
                                }
                            }
                        }
                    }
                    else if (commandID == EfirOrdersList.BACK_ID)
                    {
                        showMainForm();
                    }
                }
            });

            efirOrdersList.setTakingOrderCommand(Settings.getSettings().isTakeOrder());
        }
    }

    private boolean canGetTenMinutesOrder() {
        if (menuType == FunctionMenu.KIROVOGRAD_TYPE) {
            return ((System.currentTimeMillis() - lastGetTenTime) > GET_TEN_MINUTES_ORDER_PERIOD);
        } else {
            return true;
        }
    }

    private void processPreOrders(PreOrdersResponse response)
    {
        //Если событие обновления количества - просто обновляем количество и выходим
        if (response.getPacketNumber() == PN_UPDATE_PREORDERS_COUNT)
        {
            setPreordersCount(response.count());
            return;
        }
        
        //Удаляем старые предварительные заказы
        orderManager.clearPreOrders();
                
        //Сохраняем заказы в менеджер
        PreOrdersResponse.PreOrderAccumulator accumulator;
        for (int i = 0; i < response.count(); ++i)
        {
            accumulator = response.getPreOrder(i);
            orderManager.addPreOrder(accumulator.order, accumulator.signed, accumulator.isDriverSigned);
        }

        //Обновляем количество предзаказов
        setPreordersCount(orderManager.getPreOrdersCount());
   
        //Отображаем список предварительных заказов
        showPreOrders();
    }

    private void showPreOrders()
    {
        createPreOrders();

        //Чистим форму предвариетльных заказов
        preOrdersList.clear();

        //Формируем список предварительных заказов
        CellItem preorders[] = orderManager.getPreOrdersList();
        for (int i = 0; i < preorders.length; ++i)
        {
            preOrdersList.add(preorders[i]);
        }
    
        //Показываем пердварительные заказы
	setPrev(preOrdersList);
	preOrdersList.show();
    }

    private void showNewOrdersList()
    {
        createEfirOrdersList();

        //Обновляем список заказов
	updateOrders();

        //Показываем эфир заказов
	setPrev(efirOrdersList);
	efirOrdersList.show();
    }

    private void showMyOrdersList()
    {
        createMyOrdersList();

        updateOrders();

        setPrev(myOrdersList);
	myOrdersList.show();
    }

    private void showIncomingOrdersList()
    {
        createIncomingOrdersList();

        updateOrders();

        setPrev(incomingOrdersList);
	incomingOrdersList.show();
    }

    private void showOldOrdersList()
    {
        createOldOrdersList();
	
	updateOrders();
	setPrev( oldOrdersList);
	oldOrdersList.show();
    }

    private void createMyOrdersList()
    {
        if (myOrdersList == null)
        {
            myOrdersList = new OrdersList("Принятые заказы", new FormAction()
            {
                public void commandAction(int commandID)
                {
                    if (commandID == OrdersList.SHOW_ID)
                    {
                        CellItem selected = myOrdersList.getSelectedItem();
                        if (selected != null)
                        {
                            rd.setShownOrder(selected.getId());
                            showOldOrder(rd.getShownOrder(),"");
                        }

                    }
                    else if (commandID == OrdersList.BACK_ID)
                    {
                        showMainForm();
                    }
                }
            });
        }
    }

    private void createIncomingOrdersList()
    {
        if (incomingOrdersList == null)
        {
            incomingOrdersList = new OrdersList("Входящие заказы",new FormAction()
            {
                public void commandAction(int commandID)
                {
                    if (commandID == OrdersList.SHOW_ID)
                    {
                        CellItem selected = incomingOrdersList.getSelectedItem();
                        if (selected != null)
                        {
                            rd.setShownOrder(selected.getId());
                            showOldOrder(rd.getShownOrder(),"");
                        }

                    }
                    else if (commandID == OrdersList.BACK_ID)
                    {
                        showMainForm();
                    }
                }
            });

        }
    }

    private void createOldOrdersList()
    {
        if (oldOrdersList == null)
	{
            oldOrdersList = new OrdersList("Список заказов", new FormAction()
            {
                public void commandAction(int commandID)
                {
                    if (commandID == OrdersList.SHOW_ID)
                    {
                        CellItem selected = oldOrdersList.getSelectedItem();
                        if (selected != null)
                        {
                            rd.setShownOrder(selected.getId());
                            showOldOrder(rd.getShownOrder(),"");
                        }

                    }
                    else if (commandID == OrdersList.BACK_ID)
                    {
                        showMainForm();
                    }
                }
            });
        }
    }

    private void setMyOrdersList()
    {
        if (myOrdersList != null)
        {
            myOrdersList.clear();
            CellItem[] arr = orderManager.getMyOrdersLis();

            for (int i=0;i<arr.length;i++)
            {
                if (arr[i] != null)
                {
                    myOrdersList.add(arr[i]);
                }
            }
        }
    }

    private void setIncomingOrdersList()
    {
        if (incomingOrdersList != null)
        {
            incomingOrdersList.clear();
            CellItem[] arr = orderManager.getIncomingOrdersLis();

            for (int i=0;i<arr.length;i++)
            {
                if (arr[i] != null)
                {
                    incomingOrdersList.add(arr[i]);
                }
            }
        }
    }

    private void setOldOrdersList()
    {
        if (oldOrdersList!=null)
	{
            oldOrdersList.clear();
            CellItem[] arr;
            arr = orderManager.getOldOrdersLis();
            for (int i=0;i<arr.length;i++)
            {
                if (arr[i] != null)
                {
                    oldOrdersList.add(arr[i]);
                }
            }
	}
    }

    private void showNewOrder(int ID)
    {
        if (orderDetails == null)
	{
            orderDetails = new EfirOrderDetails(new FormAction()
            {
                public void commandAction(int commandID)
                {
                    if (commandID == EfirOrderDetails.BACK_ID)
                    {
                        rd.setShownOrder(-1);
                        showNewOrdersList();
                    }
                    else if (commandID == EfirOrderDetails.GET_ID)
                    {
                        //Останавливаем музыку
                        stopMusic();
                        
                        //Пытаемся взять заказ
                        doGetOrder();
                    }
                    else if (commandID == EfirOrderDetails.GET_TEN_ID) //ToDo Kvest ten
                    {
                        //Если водитель не может брать заказ
                        if (!orderManager.canGetOrders() || !canGetTenMinutesOrder())
                        {
                            //Выводим сообщение
                            showAlert("Вы не можете брать новый заказ!", AlertType.ERROR);
                            return;
                        }
                        
                        //Берем заказ
                        gettingOrder(ViewManager.getViewManager().getTenMinutesText());
                        lastGetTenTime = System.currentTimeMillis();
                    }
                }
            });
	}

        //Если надо - добавляем команду взятия заказа
        orderDetails.setCanGet(Settings.getSettings().isTakeOrder());

  
        //Устанавливаем текст
        orderDetails.setText(orderManager.getOrderDetails(ID,false, "").getText());
 
	setPrev(orderDetails);
	orderDetails.show();
    }

    public void interfaceAction()
    {
        if (Settings.getSettings().isUpdateInterface())
        {
            updateOrders();
        }
    }

    private void sendCancelRequest(int orderID)
    {
        //Показываем форму загрузки
	showProgressForm(TIMEOUT);

        //Останавливаем музыку, если она играла
        stopMusic();

        //Формируем данные для заявки
	byte[] data,body;
	body = parameterBuilder.createBodyPPSOrderCancelRequest(orderID,rd.getPeopleID());
	data = parameterBuilder.createSrvTransfereData("PointToGroup",rd.getSrvID(), 2, rd.getGUID(),true,body);

        //Отправляем заявку
	connection.send(data);

        //Обнуляем ид заказа
        rd.setShownOrder(-1);

        //Показываем нужную форму
        if (prevForm == null)
        {
            showMainMenu();
        }
        else
        {
            showPrevForm();
        }
    }

    private void showOldOrder(int ID,String type)
    {
        if (orderOldDetails ==null)
        {
            orderOldDetails = new OrderDetails(new FormAction()
            {
                public void commandAction(int commandID)
                {
                    if (commandID == OrderDetails.BACK_ID)
                    {
                        //Останавливаем музыку
                        stopMusic();

                        //Обнуляем ид заказа
                        rd.setShownOrder(-1);

                        //Показываем нужную форму
                        if (prevForm == null)
                        {
                            showMainMenu();
                        }
                        else
                        {
                            showPrevForm();
                        }
                    }
                    else if (commandID == OrderDetails.GET_ID)
                    {
                        //Останавливаем музыку
                        stopMusic();
                        //Пытаемся взять заказ
                        doGetOrder();
                    }
                    else if (commandID == OrderDetails.FUNCTIONS_ID)
                    {
                        stopMusic();
                        showFunctionMenu();
                    }
                    else if (commandID == OrderDetails.TO_CURRENT_ID)
                    {
                        if (orderManager.currentOrder()!= -1)
                        {
                            stopMusic();
                            rd.setShownOrder(orderManager.currentOrder());
                            showOldOrder(rd.getShownOrder(),"");
                        }
                    }
                    else if (commandID == OrderDetails.MESSAGES_ID)
                    {
                        showOrdersMessages();
                    }
                    else if (commandID == OrderDetails.CANCEL_ID)
                    {
                        sendCancelRequest(rd.getShownOrder());
                    }
                    else if (commandID == OrderDetails.FAST_TAKE_ID)
                    {
                        //Берем заказ
                        gettingOrder(ViewManager.getViewManager().getTenMinutesText()); //ToDo Kvest ten
                    }
                }
            });
        }

        //Получаем детали заказа
	OrderManager.OrderDatails details = orderManager.getOrderDetails(ID,false, type);

        //Устанавливаем команды
        if (!details.isError())
        {
            orderOldDetails.setCommands(true, details.getIsNew(), (orderManager.currentOrder() == ID));
        }
        else
        {
            orderOldDetails.setCommands(false, false, false);
        }

        //устанавливаем текст
	orderOldDetails.setText(details.getText());

	orderOldDetails.show();
    }

    private void doGetOrder()//Взятие показанного заказа
    {
        //Если водитель не может брать заказ
	if (!orderManager.canGetOrders())
	{
            //Выводим сообщение
            showAlert("Вы не можете брать новый заказ!", AlertType.ERROR);
            return;
        }

        //выводим форму с полем ввода времени ожидания
        showWaitTime();
    }

    void gettingOrder(String additional)
    {
        //Проверяем, не истекло ли еще время заказа
	if (orderManager.isDeleted(rd.getShownOrder(),rd.getT1(),rd.getT2(),rd.getT3()))
        {
            //Выводим сообщение
            showAlert("", "Поиск по данному заказу уже закончен!", AlertType.INFO, ViewManager.getViewManager().getForm("main_form"));
            return;
        }

        //Формируем данные для заявки
	byte[] data,body;
	body = parameterBuilder.createBodyOrderAnswer(rd.getShownOrder(),"CanGetOrder",additional,rd.getPeopleID());
	data = parameterBuilder.createSrvTransfereData("PointToGroup",rd.getSrvID(), 2, rd.getGUID(),true,body);
        //Отправляем заявку
	connection.send(data);

	//изменяем статус заказа
	orderManager.setState(rd.getShownOrder(), Order.STATE_TAKEN);
        //Запоминаем время подачи
        rd.addGivingTime(rd.getShownOrder(), additional);

        //Сбрасываем фильтры
        orderManager.setMinSum(-1);

        regionsFilterForm.selectAll();
        //сохранить фильтр
        Settings.getSettings().setFilter(regionsFilterForm.getString());

        //Обновляем формы с заказами
        createEfirOrdersList();
        createOldOrdersList();
        updateOrders();
        
        if (menuType == FunctionMenu.KIROVOGRAD_TYPE) {
            //Для кировограда сообщение не показываем
            showOldOrdersList();
        } else {
            //Выводим сообщение
            showAlert("", "Ваша заявка на данный заказ отправлена", AlertType.INFO, oldOrdersList);
        }
    }

    void showWaitTime()
    {
        if (waitForm == null)
	{
            waitForm = TimeSelectForm.createTimeSelectForm("Время подачи", "Время(мин)", "Отмена",  new FormAction()
            {
                public void commandAction(int commandID)
                {
                    if (commandID == TimeSelectForm.OK_ID)
                    {
                        //Изменяем предыдущую форму
                        DynamicForm form =  ViewManager.getViewManager().getForm("main_form");
                        if (form != null)
                        {
                            actionManagerUpdate();
                            setPrev(form);
                        }
                        
                        //Берем заказ
                        gettingOrder(waitForm.getTimeStr());
                    }
                    else if (commandID == TimeSelectForm.BACK_ID)
                    {
                        showMainForm();
                    }
                }
            });
	}

	//Выводим форму
	setPrev( waitForm);
        waitForm.reset();
	waitForm.show();
    }

    private void messageAction()
    {
        final CellItem selectedItem = archiveOrdersList.getSelectedItem();
        if (selectedItem != null)
        {
            showArchiveOrdersMessages(selectedItem.getId());
        }
    }

    private void deleteOrders()
    {
        //Удаляем заказы нужного типа
        orderManager.clearCompleted(rd.getShownOrderType());
        //обновляем меню
        updateOrders();
        //отображаем список
        showArchiveOrdersList(rd.getShownOrderType());
    }

    private void showArchiveOrdersList(int orderType)
    {
        //Сохраняем тип показанных заказов
        rd.setShownOrderType(orderType);
        
        //Если не создана форма - создаем
        if (archiveOrdersList == null)
        {
            archiveOrdersList = new ArchiveOrdersList(new FormAction()
            {
                public void commandAction(int commandID)
                {
                    switch(commandID)
                    {
                        case ArchiveOrdersList.BACK_ID : showArchivesMenu(); break;
                        case ArchiveOrdersList.MESSAGES_ID : messageAction(); break;
                        case ArchiveOrdersList.DELETE_ID : deleteOrders(); break;
                        case ArchiveOrdersList.SHOW_ID :
                                CellItem selectedItem = archiveOrdersList.getSelectedItem();
                                if (selectedItem != null)
                                {
                                    showCompletedOrderDetails(selectedItem.getId());
                                }
                              break;
                    }
                }
            });
        }

        //Обновляем список
        archiveOrdersList.clear();

        CellItem[] list = orderManager.getCompletedOrderLis(orderType);
        for (int i = 0; i < list.length; ++i)
        {
            archiveOrdersList.add(list[i]);
        }

        //отображаем список
        setPrev( archiveOrdersList);
        archiveOrdersList.show();
    }

    private void showCompletedOrderDetails(int ID)
    {
        if (orderArchiveDetails == null)
        {
            orderArchiveDetails = new ArchiveDetails(new FormAction()
            {
                public void commandAction(int commandID)
                {
                    if (commandID == ArchiveDetails.BACK_ID)
                    {
                       showArchiveOrdersList(rd.getShownOrderType());
                    }
                }
            });
        }

        orderArchiveDetails.setText(orderManager.getOrderDetails(ID, true, "").getText());

        orderArchiveDetails.show();
    }

    private void showCompletedOrder(int ID,String type)
    {
        if (orderСompletedDetails==null)
        {
            orderСompletedDetails = new ArchiveDetails(new FormAction()
            {
                public void commandAction(int commandID)
                {
                    if (commandID == ArchiveDetails.BACK_ID)
                    {
                        //Останавливаем музыку
                        stopMusic();

                        //Показываем нужную форму
                        if (prevForm==null)
                        {
                            showMainMenu();
                        }
                        else
                        {
                            showPrevForm();
                        }
                    }
                }
            });
        }

        //Получаем и устанавливаем текст заказа
        orderСompletedDetails.setText(orderManager.getOrderDetails(ID,false,type).getText());  
        orderСompletedDetails.show();
    }

    private void createFunctionMenu()
    {
        if (functionMenu == null)
        {
            functionMenu = new FunctionMenu(menuType, new FormAction()
            {
                public void commandAction(int commandID)
                {
                    if (commandID == FunctionMenu.BACK_ID)
                    {
                        showOldOrder(rd.getShownOrder(),"");
                    }
                    else
                    {
                        switch(commandID)
                        {
                            case FunctionMenu.ADD_WAIT_ID : showDriverWaiting();break;
                            case FunctionMenu.FEED_TIME_ID: showFeedTimeForm(); break;
                            case FunctionMenu.WITH_PASS_ID: withPassenger();break;
                            case FunctionMenu.CLOSE_ORDER_ID: orderDone();break;
                            case FunctionMenu.DISPETCHER_CALL_ID: doDispatcherCall(); break;
                            case FunctionMenu.CLIENT_CALL_ID: doClientCall(); break;
                            case FunctionMenu.LATE_ID: showDriverDelayForm(); break;
                            case FunctionMenu.NOT_EXIT_ID: showPassengerOut(); break;
                            case FunctionMenu.CALL_PASS_ID: doCallPassanger(); break;
                            case FunctionMenu.FEED_PAID_ID: feedPaid(); break;
                            case FunctionMenu.CANCEL_THROUGHT_BREAKING_ID: sendCancelReq(ParameterBuilder.REASON_BREAKING); break;
                            case FunctionMenu.REFUSE_ORDER_ID: sendCancelReq(ParameterBuilder.REASON_REFUSE); break;
                            case FunctionMenu.MESSAGE_ID: showOrdersMessages(); break;
                            case FunctionMenu.CANCEL_ID: sendCancelRequest(orderManager.currentOrder()); break;
                            case FunctionMenu.STOP_TIMER_ID: stopTimerAction(); break;
                            case FunctionMenu.TIMER_ID : startTimerByHand(); break;
                            case FunctionMenu.TIMER_FINISH_ID: finishTimer();break;
                            case FunctionMenu.CONNECT_TO_CLIENT: connectToClient();break;
                            case FunctionMenu.DISPETCHER_CALL_FROM_SETTINGS_ID: doDispatcherCallFromSettings(); break;
                        }
                    }
                }
            });
        }
    }

    private void finishTimer()
    {
        int timerTime = (int)TimerService.getTimerService().stopTimer() / (60 * 1000);
        if (timerTime > 0)
        {
            //Генерируем данные
            byte[] body = parameterBuilder.createDriverWaiting(orderManager.currentOrder(),timerTime,rd.getPeopleID());
            byte[] data = parameterBuilder.createSrvTransfereData("PointToGroup",rd.getSrvID(), 2, rd.getGUID(),true,body);
            //Отправляем данные
            connection.send(data);
        }

        createFunctionMenu();
        functionMenu.stopTimerEvent();
    }

    private void startTimerByHand()
    {
        TimerService.getTimerService().startTimer(0);

        createFunctionMenu();
        functionMenu.startTimerByHandEvent();
    }

    private void showFunctionMenu()
    {
       createFunctionMenu();

       //Показываем меню
       functionMenu.show();
    }

    private void showDriverWaiting()
    {
        if (driverWaiting == null)
	{
            driverWaiting = new DefaultTimeSelectForm("Добавить ожидание", "Время ожидания", "Назад", new FormAction()
            {

                public void commandAction(int commandID)
                {
                    if (commandID == TimeSelectForm.OK_ID)
                    {
                        sendDriverWaitingData();
                    }
                    else if (commandID == TimeSelectForm.BACK_ID)
                    {
                        showFunctionMenu();
                    }
                }
            });
	}

	//prevForm = driverWaiting;
        driverWaiting.reset();
	driverWaiting.show();
    }

    //Запрос об отмене заказа
    private void sendCancelReq(String reason)
    {
        //Формируем данные для заявки
	byte[] data,body;
        body = parameterBuilder.createBodyOrderCancel(orderManager.currentOrder(), reason,rd.getPeopleID());
        data = parameterBuilder.createSrvTransfereData("PointToGroup",rd.getSrvID(), 2, rd.getGUID(),true,body);
	//Отправляем заявку
	connection.send(data);
	//Выводим сообщение
        showAlert("Информация отправлена диспетчеру", AlertType.INFO);
    }


    //Отправка пакета "Подача оплачена"
    private void feedPaid()
    {
        //Формируем данные для заявки
	byte[] data,body;
        body = parameterBuilder.createBodyPickingUpCharge(orderManager.currentOrder(),rd.getPeopleID());
        data = parameterBuilder.createSrvTransfereData("PointToGroup",rd.getSrvID(), 2, rd.getGUID(),true,body);
	//Отправляем заявку
	connection.send(data);
	//Выводим сообщение
        showAlert("Информация отправлена диспетчеру", AlertType.INFO);
    }

    //Запрос на соединение с клиентом
    private void connectToClient()
    {
        //Формируем данные для заявки
	byte[] data,body;
        body = parameterBuilder.createBodyCW_ConnectDriverClient(orderManager.currentOrder(),rd.getPeopleID());
        data = parameterBuilder.createSrvTransfereData("PointToGroup",rd.getSrvID(), 2, rd.getGUID(),true,body);
	//Отправляем заявку
	connection.send(data);
	//Выводим сообщение
        showAlert("Запрос отправлен", AlertType.INFO);
    }
    
    private void withPassenger()//Оповещение о взятии пассажира
    {
        //Формируем данные для заявки
	byte[] data,body;
	body = parameterBuilder.createBodyOrderAnswer(orderManager.currentOrder(),"StartDoOrder","",rd.getPeopleID());
	data = parameterBuilder.createSrvTransfereData("PointToGroup",rd.getSrvID(), 2, rd.getGUID(),true,body);
	//Отправляем заявку
	connection.send(data);

	//Выводим сообщение
        showAlert("Cтатус заказа изменен на \"Исполняемый\"", AlertType.INFO);

        //Для Черновцов, если есть таймер - отправляем запрос "Добавить ожидание"
        if (menuType == FunctionMenu.CHERNOVTSI_TYPE)
        {
            int timerTime = (int)TimerService.getTimerService().stopTimer() / (60 * 1000);
            timerTime -= Settings.getSettings().getFreeWaitTime();
            if (timerTime > 0)
            {
                //Генерируем данные
                body = parameterBuilder.createDriverWaiting(orderManager.currentOrder(),timerTime,rd.getPeopleID());
                data = parameterBuilder.createSrvTransfereData("PointToGroup",rd.getSrvID(), 2, rd.getGUID(),true,body);
                //Отправляем данные
                connection.send(data);
            }
            
            createFunctionMenu();
            functionMenu.stopTimerEvent();
        }
    }

    private void doCallPassanger()
    {
        //Формируем данные для заявки
	byte[] data,body;

        body = parameterBuilder.createBodyCarOnAddressRequest(orderManager.currentOrder(),rd.getPeopleID());
        data = parameterBuilder.createSrvTransfereData("PointToGroup",rd.getSrvID(), 2, rd.getGUID(),true,body);
	//Отправляем заявку
	connection.send(data);
        
        //Выводим сообщение для всех сборок, кроме кировограда
        if (menuType != FunctionMenu.KIROVOGRAD_TYPE) {
            showAlert("Ваш запрос отправлен диспетчеру", AlertType.INFO);
        }
    }

//    private boolean canCloseOrder(int orderId) {
//        if (menuType == FunctionMenu.KIROVOGRAD_TYPE) {
//        "без суммы" уже считается подзаказом
//       если заказ без суммы - закрыть можно. или если без подзаказов и   
//                                                                        CheckNoSubOrderForClose == true , то могу закрыть заказ  
//        } else {
//            return true;
//        }
//    }
    
    private void orderDone()//Оповещение о закрытии заказа
    {
        int orderId = orderManager.currentOrder();
        
        //Проверяем, можем ли закрыть заказ
        //if (canCloseOrder(orderId)) {      
            //Формируем данные для заявки
            byte[] data,body;
            body = parameterBuilder.createBodyOrderAnswer(orderId, "Done","",rd.getPeopleID());
            data = parameterBuilder.createSrvTransfereData("PointToGroup",rd.getSrvID(), 2, rd.getGUID(),true,body);
            //Отправляем заявку
            connection.send(data);
            //Сбрасываем текущий заказ
            orderManager.closeCurrent();

            //Сбрасываем таймер
            stopTimerAction();

            //Обновляем список
            updateOrders();

            //Запрашиваем эфир
            sendRequestAir();

            if (menuType == FunctionMenu.KIROVOGRAD_TYPE) {
                //Сразу идем на главную
                showMainForm();
            } else {
                //Выводим сообщение
                showAlert("" , "Статус заказа изменен на \"Выполнен\"", AlertType.INFO, oldOrdersList);  
            }
//        } else {
//            //Говорим что не можем закрыть заказ
//            !!!!
//        }
    }

    private void doClientCall()
    {
        int id = orderManager.currentOrder();
        String number = orderManager.getClietntsPhoneNumber(id);
        if (number.equals(""))
        {
            //Выводим сообщение
            showAlert("Номер телефона в заказе не указан", AlertType.ERROR);
            return;
        }

        //Звоним
	String url = "tel:" + number;
	try
	{
            platformRequest(url);
	}catch(Exception e){}
    }

    private void doDispatcherCallFromSettings()
    {
        //Проверяем есть ли номер
        if (Settings.getSettings().getDispetcherCall().equals(""))
	{
            //Выводим сообщение
            showAlert("Вы не указали номер телефона", AlertType.ERROR);
            return;
	}
        //Звоним
	String url = "tel:" + Settings.getSettings().getDispetcherCall();
	try
	{
            platformRequest(url);
	}catch(Exception e){}
    }
    
    private void doDispatcherCall()
    {
        //Проверяем есть ли номер
        int id = orderManager.currentOrder();
        String number = orderManager.getDispetcherPhoneNumber(id);
        if (number.equals(""))
	{
            //Выводим сообщение
            showAlert("Номер телефона в заказе не укзан", AlertType.ERROR);
            return;
	}
        //Звоним
	String url = "tel:" + number;
	try
	{
            platformRequest(url);
	}catch(Exception e){}
    }

    private void sendFeedTime()
    {
        int time;
        try
        {
            time = Integer.parseInt(feedForm.getFeedTime());
        }catch (Exception e){time = 10;}

        //Генерируем данные
	byte[] body = parameterBuilder.createFeedTime(orderManager.currentOrder(), time, rd.getPeopleID());
        byte[] data = parameterBuilder.createSrvTransfereData("PointToGroup",rd.getSrvID(), 2, rd.getGUID(),true,body);
	//Отправляем данные
	connection.send(data);
        //Выводим сообщение об отправке
        showAlert("", "Информация была отправена диспетчеру",AlertType.INFO,functionMenu);
    }

    private void sendDriverDelayData()
    {               
        int time = driverDelayForm.getTime();

	if (time < 0)
	{
            //Выводим сообщение
            showAlert("Вы не указали время опоздания", AlertType.ERROR);
            return;
	}

        //Для черновцов отнимаем таймер
        if (menuType == FunctionMenu.CHERNOVTSI_TYPE)
        {
            TimerService.getTimerService().addOffset(time * 60 * 1000);
        }
        
	byte[] data,body;
	//Генерируем данные
	body = parameterBuilder.createDriverDelay(orderManager.currentOrder(),time,rd.getPeopleID());
	data = parameterBuilder.createSrvTransfereData("PointToGroup",rd.getSrvID(), 2, rd.getGUID(),true,body);
	//Отправляем данные
	connection.send(data);
	//Выводим сообщение об отправке
        showAlert("", "Ваш запрос отправлен диспетчеру",AlertType.INFO,functionMenu);
    }

    private void sendPassengerOutData()
    {
        //Определяем время ожидания
	int time = passengerOut.getTime();
 
        if (time < 0)
	{
            //Выводим сообщение
            showAlert("Вы не указали время ожидания", AlertType.ERROR);
            return;
	}

        byte[] data,body;
	//Генерируем данные
	body = parameterBuilder.createPassengerOut(orderManager.currentOrder(),time,rd.getPeopleID());
	data = parameterBuilder.createSrvTransfereData("PointToGroup",rd.getSrvID(), 2, rd.getGUID(),true,body);

        //Отправляем данные
	connection.send(data);

	//Выводим сообщение об отправке
        showAlert("", "Ваш запрос отправлен диспетчеру", AlertType.INFO, functionMenu); 
    }

    private void sendDriverWaitingData()
    {    
	int time = driverWaiting.getTime();

	if (time < 0)
	{
            //Выводим сообщение
            showAlert("Вы не указали время ожидания", AlertType.ERROR);
            return;
        }

	byte[] data,body;
	//Генерируем данные
	body = parameterBuilder.createDriverWaiting(orderManager.currentOrder(),time,rd.getPeopleID());
	data = parameterBuilder.createSrvTransfereData("PointToGroup",rd.getSrvID(), 2, rd.getGUID(),true,body);
	//Отправляем данные
	connection.send(data);
	//Выводим сообщение об отправке
        showAlert("", "Ваш запрос отправлен диспетчеру", AlertType.INFO,functionMenu); 
    }

    private void showFeedTimeForm()
    {
        if (feedForm == null)
        {
            feedForm = new FeedForm(new FormAction()
            {
                public void commandAction(int commandID)
                {
                    if (commandID == FeedForm.OK_ID)
                    {
                        sendFeedTime();
                    }
                    else  if (commandID == FeedForm.BACK_ID)
                    {
                        showFunctionMenu();
                    }
                }
            });
        }

        feedForm.show();
    }

    private void showDriverDelayForm()
    {
        if (driverDelayForm == null)
	{
            driverDelayForm = new DefaultTimeSelectForm("Опоздание","Время опоздания", "Назад", new FormAction()
            {
                public void commandAction(int commandID)
                {
                    if (commandID == TimeSelectForm.OK_ID)
                    {
                        sendDriverDelayData();
                    }
                    else if (commandID == TimeSelectForm.BACK_ID)
                    {
                        showFunctionMenu();
                    }
                }
            });
	}


	//Отображаем форму
	//prevForm = driverDelayForm;
        driverDelayForm.reset();
	driverDelayForm.show();
    }

    private void doCallSignChanged(CallSignChangedResponse response)
    {
	int id = response.getOrderID();
        if (id == -1)
        {
            return;
        }

        //Сбрасываем таймер, если отменили текущий
        if (id == orderManager.currentOrder())
        {
            stopTimerAction();
        }

	//Обрабатываем отмену заказа
	orderManager.orderCancel(id, "Отмененный");

        //Играем музыку
        if (!Settings.getSettings().isSwitchOffMusic())
        {
            int selectedItem = Settings.getSettings().getVoiceRington();
            switch (selectedItem)
            {
                case(0): startMusic(0,"/badorder.mid",true); break; 
                case(1): startMusic(0,"/badorder.amr",true); break;
                case(2): startMusic(0,"/badorder_v.amr",true); break;
                default: startMusic(0,"/badorder.mid",true); break;
            }
        }
        
        //Запрашиваем эфир
        sendRequestAir();
        
	//Выводим сообщение
        showCompletedOrder(id,"Заказ отменен");
    }

    private void showMessageList()
    {
        if (messageList == null)
	{
            messageList = new MessageList(new FormAction() 
            {
                public void commandAction(int commandID)
                {
                    if (commandID == MessageList.SHOW_ID)
                    {
                        if (messageList.size() > 0)
                        {
                            showMessage(messageList.size() - messageList.getSelectedIndex() -1);
                        }
                    }
                    else if (commandID == MessageList.BACK_ID)
                    {
                        showSubmenu();
                    }
                    else if (commandID == MessageList.DELETE_ID)
                    {
                        doMessageListClear();
                    }
                }
            });

            setMessageList();
	}
	
        //Отображаем список сообщений
        setPrev(messageList);
	messageList.show();
    }

    private void setMessageList()
    {
        if (messageList != null)
        {
            messageList.clear();
            String[] arr;
            arr = messageManager.getShortList(-1);
            for (int i=(arr.length-1);i>=0;i--)
            {
                messageList.add(arr[i]);
            }
	}
        //Обновляем отображение количества сообщений
	actionManagerUpdate();
    }

    private void processClearEfir(ClearEfir response)
    {
        //Чистим все заказы в эфире
        orderManager.deleteAllEfirOrders();
                
        //Обновляем список заказов в эфире
        setEfirOrdersList();
    }
    
    private void processCancelEfirOrder(CancelEfirOrder response)
    {
        //Удаляем эфирный заказ
        orderManager.deleteEfirOrder(response.getOrderID());
        
        //Обновляем список заказов в эфире
        setEfirOrdersList();
    }
    
    private void processDriverMessageResponse(DriverMessageResponse response)
    {
        //Выводим звук
        if ((!Settings.getSettings().isSwitchOffMusic())&&(Settings.getSettings().getMessageMelodyIndex() != 2))
        {

            if (Settings.getSettings().getMessageMelodyIndex() == 0)
            {
                startMusic(0,"/message.mid",false);
            }
            else
            {
                startMusic(1,Settings.getSettings().getMessageMediaFile(),false);
            }
        }
        
        //Отображаем сообщение 
        showAlert(response.getTheme(), response.getText(), AlertType.INFO);
    }
    
    private void incomingTCPMessage(TCPMessageResponse response)
    {
	//Добавляем дату
	String reciveDate = "";
        int orderID = response.getOrderID();
	try
	{
            reciveDate = Utils.dateToString(response.getReciveDate());
	}catch(Exception e){}
 
	//Если поле отправителя пустое,то это служеюное сообщение
	if (response.getFrom().equals(""))
	{
            response.setFrom("Служебное");
	}
	//значит что у водителя появился заказ.Но его не надо еще выполнять,но и нельзя разрешать брать новый заказ
	if (response.getClassName().equals("IMAP.Net.OrderIsYours_mesbindata"))
	{
            //Пока ничего не делаем
	}
	
	//Добавляем сообщение в messageManager
	messageManager.addMessage(response.getFrom(),response.getTo(),response.getMessage(),reciveDate,orderID);

        setMessageList();

        //заказ удален
        if (response.getClassName().equals("IMAP.Net.OrderIsNotYours_mesbindata"))
	{
            //Сбрасываем таймер, если отменили текущий
            if (orderID == orderManager.currentOrder())
            {
                stopTimerAction();
            }

            //Изменяем параметры заказа
            orderManager.orderCancel(orderID, "Отмененный");

            //Играем музыку
            if (!Settings.getSettings().isSwitchOffMusic())
            {
                int selectedItem = Settings.getSettings().getVoiceRington();
                switch (selectedItem)
                {
                    case(0): startMusic(0,"/badorder.mid",true); break; 
                    case(1): startMusic(0,"/badorder.amr",true); break;
                    case(2): startMusic(0,"/badorder_v.amr",true); break;
                    default: startMusic(0,"/badorder.mid",true); break;
                }
            }

            //Запрашиваем эфир
            sendRequestAir();
            
            //Отображаем какой заказ отменяется
            showCompletedOrder(orderID, "Заказ отменен");
            return;
	}

        //Выводим звук
        if ((!Settings.getSettings().isSwitchOffMusic())&&(Settings.getSettings().getMessageMelodyIndex() != 2))
        {

            if (Settings.getSettings().getMessageMelodyIndex() == 0)
            {
                startMusic(0,"/message.mid",false);
            }
            else
            {
                startMusic(1,Settings.getSettings().getMessageMediaFile(),false);
            }
        }

        //Если сообщение PopUp
	if (response.getMesType().indexOf("PopUp")!=-1)
	{
            //Проверяем нужно ли его показывать
            if (!Settings.getSettings().isShowAllMassages())
            {
                for (int i = 0; i < MESSAGE_PATTERNS.length; ++i)
                {
                    if (response.getMessage().indexOf(MESSAGE_PATTERNS[i]) != -1) 
                    {
                        return;
                    }
                }
            }
            
            String text;
            //text = "От: "+params[2]+'\n';
            text = "Текст: " + response.getMessage() +'\n';
            text += "Дата получения: " + reciveDate;
            showAlert(text, AlertType.INFO);
        }     
    }

    private void doMessageListClear()
    {
        //Удаляем сообщения
	messageManager.clear();
	//Обновляем список сообщений
	setMessageList();
    }

    private void showMessage(int number)
    {
        if (messageForm==null)
	{
            messageForm = new MessageForm(new FormAction()
            {
                public void commandAction(int commandID)
                {
                    if (commandID == MessageForm.BACK_ID)
                    {
                        showMessageList();
                    }
                }
            });
	}

        //Устанавливаем текст
        String messageText = "";
        String[] arr = messageManager.getMessage(number);
	if (arr == null)
	{
            messageText += "Данное сообщение небыло найдено";
	}
	else
	{
            if (!arr[1].equals(""))
            {
                messageText += ("Кому: " + arr[1] + '\n');
            }
            messageText += ("Текст: " + arr[2] + '\n');
            //Добавляем дату
            messageText += ("Дата получения: " + arr[3] + '\n');
	}
        messageForm.setText(messageText);

	//Отображаем форму
	setPrev( messageForm);
	messageForm.show();
    }

    private void srvMessageAnswer()//Обрабатываем SrvMessage
    {
        //Сбрасываем соединенеи
        resetConnection(true);

	//Выводим сообщение о закрытии сервера
        showAlert("Ошибка", "Работа сервера прекращена по неопределенным причинам.Попробуйте соединиться с сервером позже.", AlertType.ERROR, ViewManager.getViewManager().getForm("main_menu"));
    }

    private void showReportForm()
    {
        if (reportForm == null)
	{
            reportForm = new ReportForm(new FormAction()
            {
                public void commandAction(int commandID)
                {
                    if (commandID == ReportForm.SHOW_ID)
                    {
                        switch (reportForm.getType())
                        {
                            case ReportForm.TIME_TYPE: getTimeReport();break;
                            case ReportForm.COUNT_TYPE: getCountReport();break;
                        }
                    }
                    else if (commandID == ReportForm.BACK_ID)
                    {
                        showArchivesMenu();
                    }
                }
            });
	}

	//Отображаем форму
	setPrev( reportForm);
	reportForm.show(true);
    }

    private void doLoadCurrentState()
    {
        //Взводим флаг
        rd.setIsStateRequest(true);
        rd.setIsUsersRequest(true);
        checkForPositionUpdates();
    }

    private void loadCurrentState()
    {
        byte[] data,body;
	body = parameterBuilder.createBodyGetDriverParkingPosition(rd.getPeopleID());
	data = parameterBuilder.createSrvTransfereData("PointToGroup",rd.getSrvID(), 2, rd.getGUID(),true,body);
	//Показываем форму загрузки
	showProgressForm(TIMEOUT);
	//Отправляем данные
	connection.send(data);
    }

    private void analyzeDriverParkingPosition(DriverParkingPositionResponse response)
    { 
        if (rd.isIsUsersRequest())
        {
            rd.setIsUsersRequest(false);
            //Сохраняем пришедшую информацию
            if (response.getRegisteredOnParking() == 0)
            {
                rd.setInfoTemp("Водитель нигде не зарегистрирован");
                positionManager.clearUIDInf();
                if (rd.isIsUpdating())
                {
                    rd.setIsUpdating(false);
                    showStateParkingsList(rd.getShownRegion());
                }
                else
                {
                    showStateForm();
                }
            }
            else
            {
                int UIDInf = response.getUID();
                positionManager.setUIDInf(UIDInf);

                rd.setInfoTemp("Стоянка " + positionManager.getNameByID(UIDInf) + 
                                ((menuType == FunctionMenu.CHERNOVTSI_TYPE) ? "" :
                                  (",  в очереди " + response.getPosition())) + '\n');
                if (rd.isIsUpdating())
                {
                    rd.setIsUpdating(false);
                    showStateParkingsList(rd.getShownRegion());
                }
                else
                {
                    //Определяем регион
                    String regionName;
                    regionName = positionManager.getRegionByPositionID(UIDInf);

                    //Отображаем список
                    showStateParkingsList(regionName);
                }
            }        
        }
        else
        {
            String message;
            if (response.getRegisteredOnParking() == 0)
            {
                message = "Водитель нигде не зарегистрирован";
            }
            else
            {
               int UIDInf = response.getUID();
               message = "Стоянка" + " "+positionManager.getNameByID(UIDInf) + ",  " + "в очереди" + " " + response.getPosition();
            }
            showAlert(message, AlertType.INFO);
        }
    }

    private void getTimeReport()
    {
        byte[] data,body;
        //Генерируем данные
        long long_from = reportForm.getDateForm();
        long long_to = reportForm.getDateTo();

        if (long_from == -1 || long_to == -1)
        {
            showAlert("Неверно указана дата. Укажите в формате дд.мм.гггг", AlertType.ERROR);
            return;
        }
        
	long_from = ((long_from + Long.parseLong("62135596800000"))*10000);
	long_to = ((long_to + Long.parseLong("62135596800000"))*10000);
	body = parameterBuilder.createGetWorkReport(long_from, long_to, rd.getPeopleID());
	data = parameterBuilder.createSrvTransfereData("PointToGroup",rd.getSrvID(), 2, rd.getGUID(),true,body);
	//Показываем форму загрузки
	showProgressForm(TIMEOUT);
	//Отправляем данные
	connection.send(data);
    }

    private void getCountReport()
    {
        
    }

    private void showReport(WorkReportResponse response)
    {
	if (reportForm == null)
	{
            showArchivesMenu();
            return;
	}
	//Чистим форму
        reportForm.clear();
        
	//Выводим отчет
	if (response.getItems().length > 0)
	{
            reportForm.add(" \n");
            for (int i=0;i<response.getItems().length-1;i++)
            {
		reportForm.add(response.getItems()[i] + "мин)\n");
            }
            reportForm.add("Всего на смене(мин): " + response.getItems()[response.getItems().length-1]);
	}

	//Отображаем форму
	setPrev( reportForm);
	reportForm.show(false);
    }


    private void showPassengerOut()
    {
        if (passengerOut == null)
	{
            passengerOut = new DefaultTimeSelectForm("Не выходят", "Время ожидания", "Назад", new FormAction()
            {
                public void commandAction(int commandID)
                {
                    if (commandID == TimeSelectForm.OK_ID)
                    {
                        sendPassengerOutData();
                    }
                    else if (commandID == TimeSelectForm.BACK_ID)
                    {
                        showFunctionMenu();
                    }
                }
            });
	}

	//prevForm = passengerOut;
        passengerOut.reset();
        passengerOut.show();
    }
    
    private void requestOrders()
    {
        byte[] data,body;
        //Генерируем данные
        String filter = "AutoDriverID = "+ rd.getPeopleID() +" AND Folder <> 23 AND Folder <> 24 AND Folder <> 25 AND Folder <> 26";
        if (BuildInfo.DISP_ORDER_NUMBER > 2) {           
            body = parameterBuilder.createGetOrdersOfDriver(filter, rd.getPeopleID());
        } else {
            body = parameterBuilder.createGetOrders(filter);
        }
	data = parameterBuilder.createSrvTransfereData("PointToGroup",rd.getSrvID(), 2, rd.getGUID(),true,body);
	//Отправляем данные
	connection.send(data);
    }

    private void showStateParkingsList(String regionName)
    {
        rd.setShownRegion(regionName);
        if (statisticList == null)
        {
            statisticList = new StatisticList(new FormAction()
            {
                public void commandAction(int commandID)
                {
                    if (commandID == StatisticList.REGISTRATION_ID)
                    {
                        CellItem selectedItem = statisticList.getSelectedItem();
                        //Если нет стоянок - ничего не делаем
                        if (selectedItem != null)
                        {
                            byte[] data,body;
                            //Показываем форму загрузки
                            showProgressForm(TIMEOUT);

                            //Генерируем данные
                            body = parameterBuilder.createBodyRegisterOnTaxiParking(selectedItem.getId(), Settings.getSettings().getNick(),rd.getPeopleID());
                            data = parameterBuilder.createSrvTransfereData("PointToGroup",rd.getSrvID(),2,rd.getGUID(),true,body);
                            //Отправляем данные
                            connection.send(data);
                        }
                    }
                    else if (commandID == StatisticList.UPDATE_ID)
                    {
                        rd.setIsUpdating(true);
                        rd.setIsStateRequest(true);
                        rd.setIsUsersRequest(true);
                        getStatistic();
                    }
                    else if (commandID == StatisticList.UNREGISTER_ID)
                    {
                        unregisterParkingRequest();
                    }
                    else if (commandID == StatisticList.BACK_ID)
                    {
                        showStateForm();
                    }
                }
            });
        }

        //Обновляем список стоянок
        updateStatisticList(regionName);

         //Отображаем список стоянок
        setPrev( statisticList);
        statisticList.show();
    }

    private void showParkingList(String regionName)
    {
        rd.setShownRegion(regionName);
        if (parkingList == null)
        {
            parkingList = new ParkingList(new FormAction()
            {
                public void commandAction(int commandID)
                {
                    if (commandID == ParkingList.REGISTRATION_ID)
                    {
                        CellItem selectedItem = parkingList.getSelectedItem();
                        //Если нет стоянок - ничего не делаем
                        if (selectedItem != null)
                        {
                            byte[] data,body;
                            //Показываем форму загрузки
                            showProgressForm(TIMEOUT);

                            //Генерируем данные
                            body = parameterBuilder.createBodyRegisterOnTaxiParking(selectedItem.getId(), Settings.getSettings().getNick(),rd.getPeopleID());
                            data = parameterBuilder.createSrvTransfereData("PointToGroup",rd.getSrvID(), 2, rd.getGUID(),true,body);
                            //Отправляем данные
                            connection.send(data);
                        }
                    }
                    else if (commandID == ParkingList.UPDATE_ID)
                    {
                        rd.setIsUpdating(true);
                        getStatistic();
                    }
                    else if (commandID == ParkingList.UNREGISTER_ID)
                    {
                        unregisterParkingRequest();
                    }
                    else if (commandID == ParkingList.BACK_ID)
                    {
                        showRegionList();
                    }
                }
            });
        }
        //Обновляем список стоянок
        updateParkingForm(regionName);

        //Отображаем список стоянок
        setPrev(parkingList);
        parkingList.show();
    }

    private void updateStatisticList(String regionName)
    {
        //Удаляем старые стоянки
        statisticList.clear();

        //Обновляем надпись вверху
        statisticList.setComment(rd.getInfoTemp());

        //Определяем стояник
        CellItem[] arr = positionManager.getParkingForStatistic(regionName);
        
        //Выводим новые
        for (int i = 0; i < arr.length; ++i)
        {
            statisticList.add(arr[i]);
        }
    }

    private void updateParkingForm(String regionName)
    {
        //Определяем регион
        CellItem[] arr = positionManager.getParking(regionName);

        //Удаляем старые стоянки
        parkingList.clear();

        //Выводим новые
        for (int i = 0; i < arr.length; ++i)
        {
            parkingList.add(arr[i]);
        }
    }

    private void showLoadForm()
    {
        loadForm = new LoadForm(new FormAction()
        {
            public void commandAction(int commandID)
            {
                if (commandID == LoadForm.LOAD_ID)
                {
                    //Загружаем версию
                    try
                    {
                        platformRequest(rd.getNewVersionLink());
                        notifyDestroyed();
                    }catch(Exception e){}
                }
            }
        });
                
        //Отображаем форму
        loadForm.show();
    }

    private void createOrdersMessagesList()
    {
         ordersMessageList = new MessageList(new FormAction()
         {
            public void commandAction(int commandID)
            {
                if (commandID == MessageList.SHOW_ID)
                {
                    if (ordersMessageList.size() > 0)
                    {
                        int index = ordersMessageList.size() - 1 - ordersMessageList.getSelectedIndex();
                        showOrdersMessage(rd.getShownOrder(),index);
                    }
                }
                else if (commandID == MessageList.DELETE_ID)
                {
                    //Удаляем сообщение
                    messageManager.clear(rd.getShownOrder());
                    //Обновляем общий список сообщений
                    setMessageList();

                    //Выводим пустую форму с сообщениями
                    showOrdersMessages();
                }
                else if (commandID == MessageList.BACK_ID)
                {
                    showOldOrder(rd.getShownOrder(),"");
                }
            }
        });
    }

    private void createArchiveOrdersMessagesList()
    {
        String[] Strings;
        Strings = new String[0];
        archiveOrdersMessageList = new MessageList(new FormAction() 
        {
            public void commandAction(int commandID)
            {
                if (commandID == MessageList.SHOW_ID)
                {
                    if (archiveOrdersMessageList.size() > 0)
                    {
                        int index = archiveOrdersMessageList.size() - 1 - archiveOrdersMessageList.getSelectedIndex();
                        showArchiveOrdersMessage(rd.getOrderArchiveID(),index);
                    }
                }
                else if (commandID == MessageList.DELETE_ID)
                {
                    //Удаляем сообщение
                    messageManager.clear(rd.getOrderArchiveID());
                    //Обновляем общий список сообщений
                    setMessageList();

                    showArchiveOrdersList(rd.getShownOrderType());
                }
                else if (commandID == MessageList.BACK_ID)
                {
                    showArchiveOrdersList(rd.getShownOrderType());
                }
            }
        });
    }

    private void showArchiveOrdersMessages(int orderID)
    {
        rd.setOrderArchiveID(orderID);
        if (archiveOrdersMessageList==null)
        {
            createArchiveOrdersMessagesList();
        }
        //Показываем список сообщений по данному заказу
        String[] arr;
        arr = messageManager.getShortList(orderID);

        archiveOrdersMessageList.clear();
        for (int i=(arr.length-1);i>=0;i--)
        {
            archiveOrdersMessageList.add(arr[i]);
        }
        
        //Отображаем форму c сообщениями
        setPrev( archiveOrdersMessageList);
        archiveOrdersMessageList.show();

    }
    
    private void showOrdersMessages()
    {
        //Создаем форму
        if (ordersMessageList == null)
        {
            createOrdersMessagesList();
        }
        //Показываем список сообщений по данному заказу
        String[] arr = messageManager.getShortList(rd.getShownOrder());
        ordersMessageList.clear();

        for (int i=(arr.length-1);i>=0;i--)
        {
            ordersMessageList.add(arr[i]);
        }
        
        //Отображаем форму c сообщениями
        ordersMessageList.show();
    }

    private void showArchiveOrdersMessage(int orderID,int messageIndex)
    {
        if (archiveOrderMessageForm == null)
        {
            archiveOrderMessageForm = new MessageForm(new FormAction() 
            {
                public void commandAction(int commandID)
                {
                    if (commandID == MessageForm.BACK_ID)
                    {
                         showArchiveOrdersMessages(rd.getOrderArchiveID());
                    }
                }
            });
        }

        //Формируем текст
	String[] arr;
	arr = messageManager.getMessage(orderID, messageIndex);

        String text = "";
        if (arr==null)
	{
            text = "Данное сообщение небыло найдено";
	}
        else
	{
            if (!arr[1].equals(""))
            {
                text += ("Кому: " + arr[1] + '\n');
            }
            text += ("Текст: " + arr[2] + '\n');
            //Добавляем дату
            text +=("Дата получения:" + arr[3] + '\n');
	}
        archiveOrderMessageForm.setText(text);

        //Отображаем форму
	archiveOrderMessageForm.show();
    }

    private void showOrdersMessage(int orderID,int messageIndex)
    {
        if (orderMessageForm == null)
	{
            orderMessageForm = new MessageForm(new FormAction() 
            {
                public void commandAction(int commandID)
                {
                    if (commandID == MessageForm.BACK_ID)
                    {
                        showOrdersMessages();
                    }
                }
            });
	}

        //Заполняем сообщением
	String[] arr = messageManager.getMessage(orderID, messageIndex);
        String text = "";
        if (arr == null)
	{
            text = "Данное сообщение небыло найдено";
	}
        else
	{
            //messageForm.append(pl.getValue("txt_from")+arr[0]+'\n');
            if (!arr[1].equals(""))
            {
                text += ("Кому: " + arr[1] + '\n');
            }
            text += ("Текст: " + arr[2] + '\n');
            //Добавляем дату
            text += ("Дата получения: " + arr[3] + '\n');
	}
        orderMessageForm.setText(text);

        //Отображаем форму
	orderMessageForm.show();
    }

    private void doClearRMS()
    {
        //Удаляем ненужные RMS
        try
        {
           RecordStore.deleteRecordStore("messages");
           RecordStore.deleteRecordStore("orders");
           RecordStore.deleteRecordStore("positionsDB");
           RecordStore.deleteRecordStore("optionsDB");

        }catch(Exception e){}

        //чистим коллекции
        orderManager.deleteAll();
        positionManager.clear();
        positionManager.setLastChange(0);
        Settings.getSettings().setLastUpdate(-1l);

        //Сохраняем настройки
        Settings.getSettings().save();

        showAlert("Очистка выполнена", AlertType.INFO);
    }

    private byte[] createTariffzoneRequest()
    {
        byte[] data,body;
        //Генерируем данные
        //String SQLstr = "SELECT ZoneID, Name FROM tariffzone ORDER BY Name";
        String SQLstr = "SELECT Name FROM tariffzone ORDER BY Name";
        body = parameterBuilder.createSQL(SQLstr);
        data = parameterBuilder.createSrvTransfereData("PointToGroup",rd.getSrvID(), 2, rd.getGUID(),true,body);

        return data;
    }

    private void getTariffzone()
    {
         byte[] data;
         data = createTariffzoneRequest();
         
         //Отправляем данные
         connection.send(data);
    }

    private void createRegionsFilterForm()
    {
        regionsFilterForm = new RegionsFilterForm(regionsFilter);

        regionsFilterForm.setListener(new RegionsFilterForm.FilterUpdate()
        {
            public void updateFilterAction(String filterStr) 
            {
                //сохранить фильтр
                Settings.getSettings().setFilter(filterStr);

                //Отображаем меню
                showMainForm();
            }

            public void updateFilterBack()
            {
                //Отображаем меню
                showMainForm();
            }
        });
    }
    
    private void showFilterForm()
    {
        //Создаем форму с фильтрами
        if (regionsFilterForm == null)
        {
            createRegionsFilterForm();
        }

        if (regionsFilter.isEmpty())
        {
            rd.setShowFilterForm(true);
            
            //Показываем форму загрузки
            showProgressForm(TIMEOUT);

            //Запрашиваем стоянки
            getTariffzone();
        }

        regionsFilterForm.show();
    }

    private void  doSaveTariffzone(SQLResponse response)
    {
        if (response.getTariffzones() == null)
        {
            if (rd.isShowFilterForm())
            {
                showAlert("", "Ошибка при загрузке регионов", AlertType.ERROR, ViewManager.getViewManager().getForm("main_form"));
            }
        }
        else
        {
            //Обновляем список регионов в фильтре
            regionsFilter.updateRegions(response.getTariffzones());

            //сохранить фильтр
            Settings.getSettings().setFilter(regionsFilter.getString(false));

            //Обновляем список регионов
            if (regionsFilterForm != null)
            {
                regionsFilterForm.update();
            }

            if (rd.isShowFilterForm())
            {
                //Отображаем форму с фильтрами
                showFilterForm();
            }
        }
    }

    private void showSumFilterForm()
    {
        createSumFilterForm();

        //Отображаем форму
        setPrev( sumFilterForm);
        sumFilterForm.show(Integer.toString(orderManager.getMinSum()));
    }

    private void showCallForm()
    {
        if (phoneForm == null)
        {
            phoneForm = new PhoneForm(new FormAction()
            {
                public void commandAction(int commandID)
                {
                    if (commandID == PhoneForm.CALL_ID)
                    {
                        String phoneNumber = phoneForm.getPhoneNumber();
                        if (phoneNumber.equals(""))
                        {
                            showAlert("Вы не указали номер телефона", AlertType.ERROR);
                        }
                        else
                        {
                            try
                            {
                                platformRequest("tel:" + phoneNumber);
                            }catch(Exception e){}
                        }
                    }
                    else if (commandID == PhoneForm.BACK_ID)
                    {
                        showMainForm();
                    }
                }
            });
        }

        //Отображаем форму
        setPrev( phoneForm);
        phoneForm.show();
    }

    private void lockClearRMS() {
        DynamicForm form =  ViewManager.getViewManager().getForm("main_menu");

        if (form != null)
        {
            form.deleteListItemByAction("clear_rms");
        }
    }
    
    private void createSumFilterForm()
    {
        if (sumFilterForm == null)
        {
            sumFilterForm = new SumFilterForm(new FormAction()
            {
                public void commandAction(int commandID)
                {
                    if (commandID == SumFilterForm.OK_ID)
                    {
                        try
                        {
                            orderManager.setMinSum(Integer.parseInt(sumFilterForm.getSum()));
                        }
                        catch(Exception ex){}
                        showMainForm();
                    }
                    else if (commandID == SumFilterForm.BACK_ID)
                    {
                        showMainForm();
                    }
                }
            });
        }
    }

    private void requestPreOrders()
    {
        //Показываем форму загрузки
	showProgressForm(TIMEOUT);

        //Формируем данные для заявки
	byte[] data,body;
	body = parameterBuilder.createReqPreOrders(rd.getPeopleID());
	data = parameterBuilder.createSrvTransfereData("PointToGroup",rd.getSrvID(), 2, rd.getGUID(),true,body);
                
        //Отправляем заявку
	connection.send(data);
    }

    //Метод регистрирует обработчики
    private void registerActions()
    {
        //Соединение c cервером
        ActionManager.getManager().addAction("enter_act", new ActionManager.ActionCallback()
        {
            public void action()
            {
                doEnter();
            }
        });

        //Выход с закрытием смены
        ActionManager.getManager().addAction("exit_endrelay_act", new ActionManager.ActionCallback()
        {
            public void action()
            {
                if (connection!=null && connection.isOpen())
                {
                    doExitWithClosing("EndRelay");
                }
                else
                {
                    destroyApp(true);
                }
            }
        });

        //Отобрадение формы с логином
        ActionManager.getManager().addAction("nick_act", new ActionManager.ActionCallback()
        {
            public void action()
            {
                showPasswordForm();
            }
        });

        //Отобрадение формы настроек
        ActionManager.getManager().addAction("options_act", new ActionManager.ActionCallback()
        {
            public void action()
            {
                showOptions();
            }
        });

        //Отобрадение формы настроек
        ActionManager.getManager().addAction("options_pass", new ActionManager.ActionCallback()
        {
            public void action()
            {
                showPasswordFormSettings();
            }
        });
        
        //Очистка RMS
        ActionManager.getManager().addAction("clear_rms", new ActionManager.ActionCallback()
        {
            public void action()
            {
                doClearRMS();
            }
        });

        //Выход
        ActionManager.getManager().addAction("exit_act", new ActionManager.ActionCallback()
        {
            public void action()
            {
                doExit();
            }
        });

        //Отображение формы "Эфир"
        ActionManager.getManager().addAction("efir_act", new ActionManager.ActionCallback()
        {
            public void action()
            {
                showNewOrdersList();
            }
        });

        //Отображение формы "Заказы"
        ActionManager.getManager().addAction("orders_act", new ActionManager.ActionCallback()
        {
            public void action()
            {
                showOldOrdersList();
            }
        });

        //Отображение формы "Архив заказов"
        ActionManager.getManager().addAction("archives_act", new ActionManager.ActionCallback()
        {
            public void action()
            {
                showArchivesMenu();
            }
        });

        //Форма отображения фильтра
        ActionManager.getManager().addAction("filter_act", new ActionManager.ActionCallback()
        {
            public void action()
            {
                showFilterForm();
            }
        });

        //Возврат в главное меню
        ActionManager.getManager().addAction("show_main_menu", new ActionManager.ActionCallback()
        {
            public void action()
            {
                //Возвращаемся в главное меню
                showMainMenu();
            }
        });

        ActionManager.getManager().addAction("positions_info", new ActionManager.ActionCallback()
        {
            public void action()
            {
                checkForPositionUpdates();
            }
        });

        ActionManager.getManager().addAction("unregister_parking", new ActionManager.ActionCallback()
        {
            public void action()
            {
                unregisterParkingRequest();
            }
        });

        ActionManager.getManager().addAction("call_dispetcher", new ActionManager.ActionCallback()
        {
            public void action()
            {
                doDispatcherCallFromSettings();
            }
        });

        ActionManager.getManager().addAction("messages", new ActionManager.ActionCallback()
        {
            public void action()
            {
                showMessageList();
            }
        });

        ActionManager.getManager().addAction("current_state", new ActionManager.ActionCallback()
        {
            public void action()
            {
                doLoadCurrentState();
            }
        });

        ActionManager.getManager().addAction("get_pre_orders", new ActionManager.ActionCallback()
        {
            public void action()
            {
                //Запрашиваем предварительные заказы
                requestPreOrders();
            }
        });

        ActionManager.getManager().addAction("in_orders", new ActionManager.ActionCallback()
        {
            public void action()
            {
                //Заказы, предложенные водителю
                showIncomingOrdersList();
            }
        });

        ActionManager.getManager().addAction("my_orders", new ActionManager.ActionCallback()
        {
            public void action()
            {
                //Принятые заказы
                showMyOrdersList();
            }
        });

        ActionManager.getManager().addAction("sum_filter_act", new ActionManager.ActionCallback()
        {
            public void action()
            {
                //Фильтр по сумме
                showSumFilterForm();
            }
        });

        ActionManager.getManager().addAction("call_act", new ActionManager.ActionCallback()
        {
            public void action()
            {
                //Позвонить
                showCallForm();
            }
        });
        
        ActionManager.getManager().addAction("get_balance", new ActionManager.ActionCallback()
        {
            public void action()
            {
                //Запрашиваем баланс
                getBalance();
            }
        });
        
        ActionManager.getManager().addAction("change_state", new ActionManager.ActionCallback()
        {
            public void action()
            {
                //Меняем состояние
                changeState();
            }
        });
    }
        
    private void setPreordersCount(int count)
    {
        ActionManager.getManager().addText("pre_order_change", "(" + count + ")");
    }
    
    private void actionManagerUpdate()
    {
        ActionManager.getManager().setText("messages_change", "Сообщения("+messageManager.getCount()+")");
        ActionManager.getManager().setText("efir_change", "Эфир("+orderManager.getNewOrderCount()+")");
        ActionManager.getManager().setText("order_change", "Заказы("+orderManager.getOldOrderCount()+")");
        ActionManager.getManager().setText("in_change","Входящие заказы" + "(" +orderManager.getIncomingOrdersCount()+")");
        ActionManager.getManager().setText("my_change","Принятые заказы" + "(" +orderManager.getMyOrdersCount()+")");
    }

    private void processOrders(GetOrdersResponse response)
    { 
        //Чистим заказы
        orderManager.clearAllExceptArchive();
        
        //Обрабатываем новые заказы
        for (int i = 0; i < response.count(); ++i)
        { 
            try
            {
                orderManager.processIncomingOrder(response.getOrder(i));
            }catch(Exception e){}
        }
    }
    
    public OrderManager getOrderManager()
    {
        return orderManager;
    }
    
    private void sendRequestAir() {
        if (menuType == FunctionMenu.KIROVOGRAD_TYPE) {
            byte[] data,body;
            //Генерируем данные
            body = parameterBuilder.createBodyRequestAir(rd.getPeopleID());
            data = parameterBuilder.createSrvTransfereData("PointToGroup",rd.getSrvID(), 2, rd.getGUID(),true,body);

            //Отправляем данные
            connection.send(data);
        }
    }
}